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

skh2015java · · 2715 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。
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
  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. 结果输出:1   

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

[html] view plain copy
  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
  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
  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
  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()    //1个RUnLock  
  12.     fmt.Println("1")  
  13.     l.RLock()                
  14. }  
  15.   
  16. 运行结果:1  
  17. 但是程序中先尝试 解锁读锁,然后才加读锁,但是没有报错,并且能够正常输出.  

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

[html] view plain copy
  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初始值为0,调用RUnLock之后变为-1,继续往下执行  
  8.         // A writer is pending.  
  9.         if atomic.AddInt32(&rw.readerWait, -1) == 0 { //此时readerwaiter变为1,1-1之后变为0,可以继续以后的操作.</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
  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一个,也只能早于1个(注:虽然代码允许,但是强烈不推荐使用),并且在早于之后必须利用RLock进行加锁才可以继续使用.





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


有疑问加站长微信联系(非本文作者)

本文来自:CSDN博客

感谢作者:skh2015java

查看原文:golang中读写锁RWMutex和通用锁Mutex的使用

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:1006366459

2715 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传