GoLang中的互斥锁Mutex和读写锁RWMutex使用教程

目录
  • 一、竞态条件与临界区和同步工具
    • （1）竞态条件
    • （2）临界区
    • （3）同步工具
  • 二、互斥量
  • 三、使用互斥锁的注意事项
    • （1）使用互斥锁的注意事项
    • （2）使用defer语句解锁
    • （3）sync.Mutex是值类型
  • 四、读写锁与互斥锁的异同
    • （1）读/写互斥锁
    • （2）读写锁规则
    • （3）解锁读写锁

一、竞态条件与临界区和同步工具

（1）竞态条件

一旦数据被多个线程共享，那么就会产生冲突和争用的情况，这种情况被称为竞态条件。这往往会破坏数据的一致性。

同步的用途有两个，一个是避免多线程在同一时刻操作同一个数据块，另一个是协调多线程，以避免它们在同一时刻执行同一个代码块。

（2）临界区

一个线程在想要访问某一个共享资源的时候，需要先申请对该资源的访问权限，并且只有在申请成功之后，访问才能真正开始。

而当线程对共享资源的访问结束时，它还必须归还对该资源的访问权限，若要再次访问仍需申请。

我们可以说，多个并发运行的线程对这个共享资源的访问是完全串行的，只要一个代码片段需要实现对共享资源的串行化访问，就可以被视为一个临界区。由于要访问到资源而必须进入到那个区域。

（3）同步工具

临界区总是受保护的，否则会产生竞态条件。施加保护的重要手段之一，就是使用实现了某种同步机制的工具，也称为同步工具。

二、互斥量

mutual exclusion，简称mutex

在Go语言中，可供我们选择的同步工具不少。其中，最重要且最常用的同步工具当属互斥量（mutual exclusion，简称mutex）。

sync包中的Mutex就是与其对应的类型，该类型的值可以被称为互斥量或者互斥锁。

一个互斥锁可以被用来保护一个临界区或者一组临界区。我们可以通过它来保证，在同一时刻只有一个goroutine处于该临界区。

为了实现这个保证，每当有goroutine想进入临界区，都要先对它进行锁定，并且，每个goroutine离开临界区，都要及时对它进行解锁。

  • 锁定操作：调用互斥锁的Lock方法；
  • 解锁操作：调用互斥锁的Unlock方法；
mu.Lock()
_, err := writer.Write([]byte(data))
if err != nil {
 log.Printf("error: %s [%d]", err, id)
}
mu.Unlock()

go run demo01.go -protecting=0

三、使用互斥锁的注意事项

（1）使用互斥锁的注意事项

使用互斥锁的注意事项如下：

  • 不要重复锁定互斥锁；
  • 不要忘记解锁互斥锁，必要时使用defer语句；
  • 不要对尚未锁定或已解锁的互斥锁解锁；
  • 不要在多个函数之间传递互斥锁；

把一个互斥锁同时用在多个地方，不但会让程序变慢，还会大大增加死锁的可能性。

有GO语言运行时系统自行抛出的panic都属于致命错误，都是无法被恢复的，调用recover函数对他们起不到任何作用。也就是说，一旦产生死锁，程序必然崩溃。

为了避免这种情况，最简单有效的方法就是让每一个互斥锁都只保护一个临界区或一组相关临界区。在这个前提下，还要注意，就不要重复锁定一个互斥锁，也不要忘记对它的解锁。

一个goroutine对某一个互斥锁重复锁定，就意味着它自己锁死自己。

不要忘记解锁的一个重要原因是：避免重复锁定。

同样，解锁未锁定的互斥锁会立即引发 panic。

（2）使用defer语句解锁

最保险的做法

如果一个流程在锁定了某个互斥锁之后分叉了，或者有被中断的可能，那么就应该使用defer语句来对它进行解锁，而且这样的defer语句应该紧跟在锁定操作之后。这是最保险的一种做法。

（3）sync.Mutex是值类型

Go 语言中的互斥锁是开箱即用的。换句话说，一旦我们声明了一个sync.Mutex类型的变量，就可以直接使用它了。

不过要注意，该类型是一个结构体类型，属于值类型中的一种。把它传给一个函数、将它从函数中返回、把它赋给其他变量、让它进入某个通道都会导致它的副本的产生。

并且，原值和它的副本，以及多个副本之间都是完全独立的，它们都是不同的互斥锁。

四、读写锁与互斥锁的异同

（1）读/写互斥锁

读写锁是读/写互斥锁的简称。在Go语言中，读写锁由sync.RWMutex类型的值代表。与sync.Mutex类型一样，也是开箱即用。

一个读写锁中，实际包含两个锁，即：读锁和写锁。

sync.RWMutex类型中的Lock方法和Unlock方法分别用于对写锁进行锁定和解锁，而它的RLock方法和RUnlock方法则分别用于对读锁进行锁定和解锁。

（2）读写锁规则

  • 在写锁已被锁定的情况下再试图锁定写锁，会阻塞当前的 goroutine。
  • 在写锁已被锁定的情况下试图锁定读锁，也会阻塞当前的 goroutine。
  • 在读锁已被锁定的情况下试图锁定写锁，同样会阻塞当前的 goroutine。
  • 在读锁已被锁定的情况下再试图锁定读锁，并不会阻塞当前的 goroutine。

多个写操作不能同时进行，写操作和读操作也不能同时进行，但多个读操作却可以同时进行。

（3）解锁读写锁

对写锁进行解锁，会唤醒“所有因试图锁定读锁，而被阻塞的 goroutine”，并且，这通常会使它们都成功完成对读锁的锁定。

对读锁进行解锁，只会在没有其他读锁锁定的前提下，唤醒“因试图锁定写锁，而被阻塞的 goroutine”；并且，最终只会有一个被唤醒的 goroutine 能够成功完成对写锁的锁定，其他的 goroutine 还要在原处继续等待。至于是哪一个 goroutine，那就要看谁的等待时间最长了。

与互斥锁类似，解锁“读写锁中未被锁定的写锁”，会立即引发 panic，对于其中的读锁也是如此，并且同样是不可恢复的。，与互斥锁类似，解锁“读写锁中未被锁定的写锁”，会立即引发 panic，对于其中的读锁也是如此，并且同样是不可恢复的。

到此这篇关于GoLang中的互斥锁Mutex和读写锁RWMutex使用教程的文章就介绍到这了,更多相关GoLang Mutex和RWMutex内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • GoLang分布式锁与snowflake雪花算法

    目录 分布式id生成器 分布式锁 负载均衡 go语言在网络服务模块有着得天独厚的优势:传送门详细介绍了涉及到的分布式相关技术. 分布式id生成器 Snowflake(雪花算法),由Twitter提出并开源,可在分布式环境下用于生成唯一ID的算法. 生成的Id是64位(int64)数值类型,包含4部分: 41bit的时间戳(毫秒):一般是相对系统上线时间的毫秒数(可用69年): 5bit的数据中心id+5bit的机器id:表示工作的计算机:实际使用时可根据情况调整两者间的比例: 12bit序列号:

  • Go并发与锁的两种方式该如何提效详解

    目录 并发不安全的例子 互斥锁 读写锁 小结 总结 并发安全,就是多个并发体在同一段时间内访问同一个共享数据,共享数据能被正确处理. 很多语言的并发编程很容易在同时修改某个变量的时候,因为操作不是原子的,而出现错误计算,比如一个加法运算使用中的变量被修改,而导致计算结果出错,典型的像统计商品库存. 个人建议只要涉及到共享变量统统使用channel,因为channel源码中使用了互斥锁,它是并发安全的. 我们可以不用,但不可以不了解,手中有粮心中不慌. 并发不安全的例子 数组是并发不安全的,在例子

  • Go语言实现分布式锁

    目录 1. go实现分布式锁 1.1 redis_lock.go 1.2 retry.go 1.3 lock.lua 1.4 lua_unlock.lua 1.5 refresh.lua 1.6 单元测试 1. go实现分布式锁 通过 golang 实现一个简单的分布式锁,包括锁续约.重试机制.singleflght机制的使用 1.1 redis_lock.go package redis_lock import ( "context" _ "embed" &quo

  • Golang分布式锁简单案例实现流程

    其实锁这种东西,都能能不加就不加,锁会导致程序一定程度上退回到串行化,进而降低效率. 首先,看一个案例,如果要实现一个计数器,并且是多个协程共同进行的,就会出现以下的情况: package main import ( "fmt" "sync" ) func main() { numberFlag := 0 wg := new(sync.WaitGroup) for i := 0; i < 200; i++ { wg.Add(1) go func() { def

  • Golang的锁机制使用及说明

    目录 踩坑点 互斥锁 Mutex 读写锁 RWMutex 谨防锁拷贝 查看数据竞争 总结 golang中的锁分为互斥锁.读写锁.原子锁即原子操作. 在 Golang 里有专门的方法来实现锁,就是 sync 包,这个包有两个很重要的锁类型.一个叫 Mutex, 利用它可以实现互斥锁. 一个叫 RWMutex,利用它可以实现读写锁. 全局锁 sync.Mutex,是同一时刻某一资源只能上一个锁,此锁具有排他性,上锁后只能被此线程使用,直至解锁.加锁后即不能读也不能写.全局锁是互斥锁,即 sync.M

  • GoLang中的互斥锁Mutex和读写锁RWMutex使用教程

    目录 一.竞态条件与临界区和同步工具 (1)竞态条件 (2)临界区 (3)同步工具 二.互斥量 三.使用互斥锁的注意事项 (1)使用互斥锁的注意事项 (2)使用defer语句解锁 (3)sync.Mutex是值类型 四.读写锁与互斥锁的异同 (1)读/写互斥锁 (2)读写锁规则 (3)解锁读写锁 一.竞态条件与临界区和同步工具 (1)竞态条件 一旦数据被多个线程共享,那么就会产生冲突和争用的情况,这种情况被称为竞态条件.这往往会破坏数据的一致性. 同步的用途有两个,一个是避免多线程在同一时刻操作

  • Go语言并发编程之互斥锁Mutex和读写锁RWMutex

    目录 一.互斥锁Mutex 1.Mutex介绍 2.Mutex使用实例 二.读写锁RWMutex 1.RWMutex介绍 2.RWMutex使用实例 在并发编程中,多个Goroutine访问同一块内存资源时可能会出现竞态条件,我们需要在临界区中使用适当的同步操作来以避免竞态条件.Go 语言中提供了很多同步工具,本文将介绍互斥锁Mutex和读写锁RWMutex的使用方法. 一.互斥锁Mutex 1.Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (R

  • GO语言协程互斥锁Mutex和读写锁RWMutex用法实例详解

    sync.Mutex Go中使用sync.Mutex类型实现mutex(排他锁.互斥锁).在源代码的sync/mutex.go文件中,有如下定义: // A Mutex is a mutual exclusion lock. // The zero value for a Mutex is an unlocked mutex. // // A Mutex must not be copied after first use. type Mutex struct { state int32 sem

  • C#多线程中的互斥锁Mutex

    C#多线程中的互斥锁Mutex

    一.简介 Mutex的突出特点是可以跨应用程序域边界对资源进行独占访问,即可以用于同步不同进程中的线程,这种功能当然这是以牺牲更多的系统资源为代价的. 主要常用的两个方法: public virtual bool WaitOne() 阻止当前线程,直到当前 System.Threading.WaitHandle 收到信号获取互斥锁. public void ReleaseMutex() 释放 System.Threading.Mutex 一次. 二.代码 案例一: class Program {

  • c#互斥锁Mutex类用法介绍

    什么是Mutex “mutex”是术语“互相排斥(mutually exclusive)”的简写形式,也就是互斥量.互斥量跟临界区中提到的Monitor很相似,只有拥有互斥对象的线程才具有访问资源的权限,由于互斥对象只有一个,因此就决定了任何情况下此共享资源都不会同时被多个线程所访问.当前占据资源的线程在任务处理完后应将拥有的互斥对象交出,以便其他线程在获得后得以访问资源.互斥量比临界区复杂,因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享,而且可以在不同应用程序的线程之间实现对

  • 详解java中的互斥锁信号量和多线程等待机制

    互斥锁和信号量都是操作系统中为并发编程设计基本概念,互斥锁和信号量的概念上的不同在于,对于同一个资源,互斥锁只有0和1 的概念,而信号量不止于此.也就是说,信号量可以使资源同时被多个线程访问,而互斥锁同时只能被一个线程访问 互斥锁在java中的实现就是 ReetranLock , 在访问一个同步资源时,它的对象需要通过方法 tryLock() 获得这个锁,如果失败,返回 false,成功返回true.根据返回的信息来判断是否要访问这个被同步的资源.看下面的例子 public class Reen

  • Go语言读写锁RWMutex的源码分析

    Go语言读写锁RWMutex的源码分析

    目录 前言 RWMutex 总览 深入源码 数据结构 RLock() RUnlock() Lock() Unlock() 常见问题 实战一下 前言 在前面两篇文章中 初见 Go Mutex .Go Mutex 源码详解,我们学习了 Go语言 中的 Mutex,它是一把互斥锁,每次只允许一个 goroutine 进入临界区,可以保证临界区资源的状态正确性.但是有的情况下,并不是所有 goroutine 都会修改临界区状态,可能只是读取临界区的数据,如果此时还是需要每个 goroutine 拿到锁依

  • C#多线程中如何运用互斥锁Mutex

    互斥锁(Mutex) 互斥锁是一个互斥的同步对象,意味着同一时间有且仅有一个线程可以获取它. 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况 函数: //创建一个处于未获取状态的互斥锁 Public Mutex(): //如果owned为true,互斥锁的初始状态就是被主线程所获取,否则处于未获取状态 Public Mutex(bool owned): 如果要获取一个互斥锁.应调用互斥锁上的WaitOne()方法,该方法继承于Thread.WaitHandle类 它处于等到状态直至所调用

  • Go语言并发编程 互斥锁详情

    目录 1.互斥锁Mutex 1.1 Mutex介绍 1.2 Mutex使用实例 2.读写锁RWMutex 2.1 RWMutex介绍 2.2 RWMutex使用实例 1.互斥锁Mutex 1.1 Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (RWMutex) 就是sync 包中的方法. 互斥锁可以用来保护一个临界区,保证同一时刻只有一个 goroutine 处于该临界区内.主要包括锁定(Lock方法)和解锁(Unlock方法)两个操作,首先对进

  • Golang Mutex互斥锁源码分析

    Golang Mutex互斥锁源码分析

    目录 前言 Mutex 特性 数据结构 Lock() Unlock() 前言 在上一篇文章中,我们一起学习了如何使用 Go 中的互斥锁 Mutex,那么本篇文章,我们就一起来探究下 Mutex 底层是如何实现的,知其然,更要知其所以然! 说明:本文中的示例,均是基于Go1.17 64位机器 Mutex 特性 Mutex 就是一把互斥锁,可以想象成一个令牌,有且只有这一个令牌,只有持有令牌的 goroutine 才能进入房间(临界区),在房间内执行完任务后,走出房间并把令牌交出来,如果还有其余的 

随机推荐