golang中读写锁RWMutex和通用锁Mutex的使用

柔光的暖阳◎ 2022-07-16 18:22 226阅读 0赞

golang中sync包实现了两种锁Mutex （互斥锁）和RWMutex（读写锁），其中RWMutex是基于Mutex实现的，只读锁的实现使用类似引用计数器的功能．

type Mutex

func (m \*Mutex) Lock()

func (m \*Mutex) Unlock()

type RWMutex

func (rw \*RWMutex) Lock()

func (rw \*RWMutex) RLock()

func (rw \*RWMutex) RLocker() Locker

func (rw \*RWMutex) RUnlock()

func (rw \*RWMutex) Unlock()

其中Mutex为互斥锁，Lock()加锁，Unlock()解锁，使用Lock()加锁后，便不能再次对其进行加锁，直到利用Unlock()解锁对其解锁后，才能再次加锁．适用于读写不确定场景，即读写次数没有明显的区别，并且只允许只有一个读或者写的场景，所以该锁叶叫做全局锁．

func (m \*Mutex) Unlock()用于解锁m，如果在使用Unlock()前未加锁，就会引起一个运行错误．

已经锁定的Mutex并不与特定的goroutine相关联，这样可以利用一个goroutine对其加锁，再利用其他goroutine对其解锁．

正常运行例子：

**\[html\]**  [view plain][]   [copy][view plain]

1.  package main  
2.    
3.  import (  
4.      "fmt"  
5.      "sync"  
6.  )  
7.    
8.  func main() \{  
9.      var l \*sync.Mutex  
10.     l = new(sync.Mutex)  
11.     l.Lock()  
12.     defer l.Unlock()  
13.     fmt.Println("1")  
14. \}  
15. 结果输出：１

当Unlock()在Lock()之前使用时，便会报错

**\[html\]**  [view plain][]   [copy][view plain]

1.  package main  
2.    
3.  import (  
4.      "fmt"  
5.      "sync"  
6.  )  
7.    
8.  func main() \{  
9.      var l \*sync.Mutex  
10.     l = new(sync.Mutex)  
11.     l.Unlock()  
12.     fmt.Println("1")  
13.     l.Lock()  
14. \}  
15. 运行结果： panic: sync: unlock of unlocked mutex

当在解锁之前再次进行加锁，便会死锁状态

**\[html\]**  [view plain][]   [copy][view plain]

1.  package main  
2.    
3.  import (  
4.      "fmt"  
5.      "sync"  
6.  )  
7.    
8.  func main() \{  
9.      var l \*sync.Mutex  
10.     l = new(sync.Mutex)  
11.     l.Lock()  
12.     fmt.Println("1")  
13.     l.Lock()  
14. \}  
15. 运行结果：  1  
16.     
17.   fatal error: all goroutines are asleep - deadlock!

RWMutex是一个读写锁，该锁可以加多个读锁或者一个写锁，其经常用于读次数远远多于写次数的场景．

func (rw \*RWMutex) Lock()　　写锁，如果在添加写锁之前已经有其他的读锁和写锁，则lock就会阻塞直到该锁可用，为确保该锁最终可用，已阻塞的 Lock 调用会从获得的锁中排除新的读取器，即写锁权限高于读锁，有写锁时优先进行写锁定  
  func (rw \*RWMutex) Unlock()　写锁解锁，如果没有进行写锁定，则就会引起一个运行时错误．

**\[html\]**  [view plain][]   [copy][view plain]

1.  package main  
2.    
3.  import (  
4.      "fmt"  
5.      "sync"  
6.  )  
7.    
8.  func main() \{  
9.      var l \*sync.RWMutex  
10.     l = new(sync.RWMutex)  
11.     l.Unlock()  
12.     fmt.Println("1")  
13.     l.Lock()  
14. \}  
15. 运行结果：panic: sync: unlock of unlocked mutex

func (rw \*RWMutex) RLock() 读锁，当有写锁时，无法加载读锁，当只有读锁或者没有锁时，可以加载读锁，读锁可以加载多个，所以适用于＂读多写少＂的场景

func (rw \*RWMutex)RUnlock()　读锁解锁，RUnlock 撤销单次 RLock 调用，它对于其它同时存在的读取器则没有效果。若 rw 并没有为读取而锁定，调用 RUnlock 就会引发一个运行时错误(注：这种说法在go1.3版本中是不对的，例如下面这个例子)。

**\[html\]**  [view plain][]   [copy][view plain]

1.  package main  
2.    
3.  import (  
4.      "fmt"  
5.      "sync"  
6.  )  
7.    
8.  func main() \{  
9.      var l \*sync.RWMutex  
10.     l = new(sync.RWMutex)  
11.     l.RUnlock()　　　　//１个RUnLock  
12.     fmt.Println("1")  
13.     l.RLock()                
14. \}  
15.   
16. 运行结果：１  
17. 但是程序中先尝试 解锁读锁，然后才加读锁，但是没有报错，并且能够正常输出．

分析：go1.3版本中出现这种情况的原因分析，通过阅读源码可以很清晰的得到结果

**\[html\]**  [view plain][]   [copy][view plain]

1.  func (rw \*RWMutex) RUnlock() \{  
2.      if raceenabled \{  
3.          \_ = rw.w.state  
4.          raceReleaseMerge(unsafe.Pointer(&rw.writerSem))  
5.          raceDisable()  
6.      \}**<****span** style="color:\#FF0000;"**>**  
7.      if atomic.AddInt32(&rw.readerCount, -1) **<** **0** \{　//readercounter初始值为０,调用RUnLock之后变为-1，继续往下执行  
8.          // A writer is pending.  
9.          if atomic.AddInt32(&rw.readerWait, -1) == 0 \{　//此时readerwaiter变为１，1-1之后变为０,可以继续以后的操作．**</****span****>**  
10.             // The last reader unblocks the writer.  
11.             runtime\_Semrelease(&rw.writerSem)  
12.         \}  
13.     \}  
14.     if raceenabled \{  
15.         raceEnable()  
16.     \}  
17. \}

当RUnlock多于RLock多个时，便会报错，进入死锁．实例如下：

**\[html\]**  [view plain][]   [copy][view plain]

1.  package main  
2.    
3.  import (  
4.      "fmt"  
5.      "sync"  
6.  )  
7.    
8.  type s struct \{  
9.      readerCount int32  
10. \}  
11.   
12. func main() \{  
13.     l := new(sync.RWMutex)  
14.     l.RUnlock()  
15.     l.RUnlock()　　　　　　　　//此处出现死锁  
16.     fmt.Println("1")  
17.     l.RLock()  
18. \}  
19. 运行结果：  
20. 1  
21.     
22.   fatal error: all goroutines are asleep - deadlock!

总结：

所以在go1.3版本中，运行过程中允许RUnLock早于RLock一个，也只能早于１个（注：虽然代码允许，但是强烈不推荐使用），并且在早于之后必须利用RLock进行加锁才可以继续使用．

原文地址：http://blog.csdn.net/chenbaoke/article/details/41957725

[view plain]: http://blog.csdn.net/chenbaoke/article/details/41957725#

发表评论取消回复

表情：

评论列表（有 0 条评论，226人围观）

还没有评论，来说两句吧...

相关阅读

相关 Golang中互斥锁和读写互斥锁

![1508e5f320a04f0d93b1b35845c19ed2.gif][] 目录互斥锁使用互斥锁的示例代码读写互斥锁读写互斥锁的示例代码 -----

阳光穿透心脏的1/2处/ 2024年03月22日 16:15/ 0 赞/ 51 阅读

相关从源码深入理解读写锁(golang-RWMutex)

在读多写少的情况下，即使一段时间内没有写操作，大量并发的读访问也不得不在Mutex的保护下变成串行访问，这种情况下，使用Mutex，对性能影响比较大。所以就要区分读写操作

╰半橙微兮°/ 2024年03月22日 13:16/ 0 赞/ 37 阅读

相关共享锁（读锁）和排他锁（写锁）

一、共享锁（读锁）：共享锁允许多个线程同时获取锁，并发访问共享资源。共享锁是一种乐观锁，允许多个执行读操作的线程同时访问共享资源。二、排它锁（写锁）：排它锁

刺骨的言语ヽ痛彻心扉/ 2023年10月14日 12:10/ 0 赞/ 47 阅读

相关重入锁和读写锁

在java多线程中，我们知道可以用synchronize关键字来实现线程间的同步互斥工作，还有更加优秀的机制去实现同步互斥工作，Lock对象。重入锁和读写锁，他们具有比

逃离我推掉我的手/ 2023年06月16日 04:59/ 0 赞/ 1 阅读

相关 Go并发编程（五）同步锁Mutex&读写锁RWMutex

文章目录 Go并发编程（五）同步锁Mutex&读写锁RWMutex Mutex 使用原理 RW

我就是我/ 2023年01月18日 06:51/ 0 赞/ 230 阅读

相关 go中的sync.Mutex 和 sync.RWMutex

介绍 golang 中的 sync 包实现了两种锁： Mutex：互斥锁 RWMutex：读写锁，RWMutex 基于 Mutex 实现 Mutex（互

左手的ㄟ右手/ 2022年12月24日 15:50/ 0 赞/ 182 阅读

相关 golang中读写锁RWMutex和通用锁Mutex的使用

golang中sync包实现了两种锁Mutex （互斥锁）和RWMutex（读写锁），其中RWMutex是基于Mutex实现的，只读锁的实现使用类似引用计数器的功能．

柔光的暖阳◎/ 2022年07月16日 18:22/ 0 赞/ 227 阅读

相关 golang 中 sync.Mutex 和 sync.RWMutex

转载: [https://www.jianshu.com/p/679041bdaa39][https_www.jianshu.com_p_679041bdaa39] 介绍

Myth丶恋晨/ 2022年04月23日 20:24/ 0 赞/ 203 阅读

相关 go并发编程之六(sync之读写锁RWMutex)

> `RWMutex`读写锁相关的介绍使用文章目录 1. 读写锁的定义 2. 读写锁的使用 1. 读写锁的定义涉及到

旧城等待，/ 2022年04月23日 08:32/ 0 赞/ 253 阅读

相关 golang sync.Mutex 互斥锁使用实例

实例： var mutex sync.Mutex //互斥锁 func printer(str string){ mutex.Lock()

柔情只为你懂/ 2021年09月07日 23:48/ 0 赞/ 659 阅读