锁的介绍

1 互斥锁

传统并发程序对共享资源进行访问控制的主要手段，由标准库代码包中sync中的Mutex结构体表示。

  1. //Mutex  是互斥锁， 零值是解锁的互斥锁， 首次使用后不得赋值互斥锁。
  2. type Mutex struct {
  3.    state int32
  4.    sema  uint32
  5. }

sync.Mutex类型只有两个公开的指针方法

  1. //Locker表示可以锁定和解锁的对象。
  2. type Locker interface {
  3.    Lock()
  4.    Unlock()
  5. }
  7. //锁定当前的互斥量
  8. //如果锁已被使用，则调用goroutine
  9. //阻塞直到互斥锁可用。
  10. func (m *Mutex) Lock() 
  12. //对当前互斥量进行解锁
  13. //如果在进入解锁时未锁定m，则为运行时错误。
  14. //锁定的互斥锁与特定的goroutine无关。
  15. //允许一个goroutine锁定Mutex然后安排另一个goroutine来解锁它。
  16. func (m *Mutex) Unlock()

声明一个互斥锁：

  1. var mutex sync.Mutex

不像C或Java的锁类工具，我们可能会犯一个错误：忘记及时解开已被锁住的锁，从而导致流程异常。但Go由于存在defer，所以此类问题出现的概率极低。关于defer解锁的方式如下：

  1. var mutex sync.Mutex
  2. func Write()  {
  3.    mutex.Lock()
  4.    defer mutex.Unlock()
  5. }

如果对一个已经上锁的对象再次上锁，那么就会导致该锁定操作被阻塞，直到该互斥锁回到被解锁状态

  1. func main()  {
  2.    var mutex sync.Mutex
  3.    fmt.Println("start lock main")
  4.    mutex.Lock()
  5.    fmt.Println("get locked main")
  6.    for i := 1;i<=3 ;i++  {
  7.       go func(i int) {  
  8.          fmt.Println("start lock ",i)
  9.          mutex.Lock()
  10.          fmt.Println("get locked ",i)
  11.       }(i)
  12.    }
  13.    time.Sleep(time.Second)
  14.    fmt.Println("Unlock the lock main")
  15.    mutex.Unlock()
  16.    fmt.Println("get unlocked main")
  17.    time.Sleep(time.Second)
  18. }

上面的示例中，我们在for循环之前开始加锁，然后在每一次循环中创建一个协程，并对其加锁，但是由于之前已经加锁了，所以这个for循环中的加锁会陷入阻塞直到main中的锁被解锁， time.Sleep(time.Second) 是为了能让系统有足够的时间运行for循环，输出结果如下：

  1. start lock main
  2. get locked main
  3. start lock  3
  4. start lock  1
  5. start lock  2
  6. Unlock the lock main
  7. get unlocked main
  8. get locked  3

最终在main解锁后，三个协程会重新抢夺互斥锁权，最终协程3获胜。
互斥锁锁定操作的逆操作并不会导致协程阻塞，但是有可能导致引发一个无法恢复的运行时的panic，比如对一个未锁定的互斥锁进行解锁时就会发生panic。避免这种情况的最有效方式就是使用defer。
我们知道如果遇到panic，可以使用recover方法进行恢复，但是如果对重复解锁互斥锁引发的panic却是徒劳的（Go 1.8及以后）。

  1. func main()  {
  2.    defer func() {
  3.       fmt.Println("Try to recover the panic")
  4.       if p := recover();p!=nil{
  5.          fmt.Println("recover the panic : ",p)
  6.       }
  7.    }()
  8.    var mutex sync.Mutex
  9.    fmt.Println("start lock")
  10.    mutex.Lock()
  11.    fmt.Println("get locked")
  12.    fmt.Println("unlock lock")
  13.    mutex.Unlock()
  14.    fmt.Println("lock is unlocked")
  15.    fmt.Println("unlock lock again")
  16.    mutex.Unlock()
  17. }

以上代码试图对重复解锁引发的panic进行recover，但是我们发现操作失败，输出结果：

  1. start lock
  2. get locked
  3. unlock lock
  4. lock is unlocked
  5. unlock lock again
  6. fatal error: sync: unlock of unlocked mutex
  8. goroutine 1 [running]:
  9. runtime.throw(0x4c17d4, 0x1e)
  10.     /usr/local/go-faketime/src/runtime/panic.go:1116 +0x72 fp=0xc000054e88 sp=0xc000054e58 pc=0x432072
  11. sync.throw(0x4c17d4, 0x1e)
  12.     /usr/local/go-faketime/src/runtime/panic.go:1102 +0x35 fp=0xc000054ea8 sp=0xc000054e88 pc=0x45f075
  13. sync.(*Mutex).unlockSlow(0xc000018018, 0xc0ffffffff)
  14.     /usr/local/go-faketime/src/sync/mutex.go:196 +0xd8 fp=0xc000054ed0 sp=0xc000054ea8 pc=0x471838
  15. sync.(*Mutex).Unlock(...)
  16.     /usr/local/go-faketime/src/sync/mutex.go:190
  17. main.main()
  18.     /tmp/sandbox908680473/prog.go:23 +0x2b9 fp=0xc000054f88 sp=0xc000054ed0 pc=0x499039
  19. runtime.main()
  20.     /usr/local/go-faketime/src/runtime/proc.go:204 +0x209 fp=0xc000054fe0 sp=0xc000054f88 pc=0x434889
  21. runtime.goexit()
  22.     /usr/local/go-faketime/src/runtime/asm_amd64.s:1374 +0x1 fp=0xc000054fe8 sp=0xc000054fe0 pc=0x462fa1

虽然互斥锁可以被多个协程共享，但还是建议将对同一个互斥锁的加锁解锁操作放在同一个层次的代码中。
2 读写锁
读写锁是针对读写操作的互斥锁，可以分别针对读操作与写操作进行锁定和解锁操作 。
读写锁的访问控制规则如下：
①多个写操作之间是互斥的
②写操作与读操作之间也是互斥的
③多个读操作之间不是互斥的
在这样的控制规则下，读写锁可以大大降低性能损耗。
由标准库代码包中sync中的RWMutex结构体表示

  1. // RWMutex是一个读/写互斥锁，可以由任意数量的读操作或单个写操作持有。
  2. // RWMutex的零值是未锁定的互斥锁。
  3. //首次使用后，不得复制RWMutex。
  4. //如果goroutine持有RWMutex进行读取而另一个goroutine可能会调用Lock，那么在释放初始读锁之前，goroutine不应该期望能够获取读锁定。 
  5. //特别是，这种禁止递归读锁定。 这是为了确保锁最终变得可用; 阻止的锁定会阻止新读操作获取锁定。
  6. type RWMutex struct {
  7.    w           Mutex  //如果有待处理的写操作就持有
  8.    writerSem   uint32 // 写操作等待读操作完成的信号量
  9.    readerSem   uint32 //读操作等待写操作完成的信号量
  10.    readerCount int32  // 待处理的读操作数量
  11.    readerWait  int32  // number of departing readers
  12. }

sync中的RWMutex有以下几种方法：

  1. //对读操作的锁定
  2. func (rw *RWMutex) RLock()
  3. //对读操作的解锁
  4. func (rw *RWMutex) RUnlock()
  5. //对写操作的锁定
  6. func (rw *RWMutex) Lock()
  7. //对写操作的解锁
  8. func (rw *RWMutex) Unlock()
  9. //返回一个实现了sync.Locker接口类型的值，实际上是回调rw.RLock and rw.RUnlock.
  10. func (rw *RWMutex) RLocker() Locker

Unlock会试图唤醒所有因欲进行读锁定而被阻塞的协程，而 RUnlock 只会在已无任何读锁定的情况下，试图唤醒一个因欲进行写锁定而被阻塞的协程。若对一个未被写锁定的读写锁进行写解锁，就会引发一个不可恢复的panic，同理对一个未被读锁定的读写锁进行读写锁也会如此。
由于读写锁控制下的多个读操作之间不是互斥的，因此对于读解锁更容易被忽视。对于同一个读写锁，添加多少个读锁定，就必要有等量的读解锁，这样才能其他协程有机会进行操作。

  1. func main() {
  2.    var rwm sync.RWMutex
  3.    for i := 0; i < 3; i++ {
  4.       go func(i int) {
  5.          fmt.Println("try to lock read ", i)
  6.          rwm.RLock()
  7.          fmt.Println("get locked ", i)
  8.          time.Sleep(time.Second *2)
  9.          fmt.Println("try to unlock for reading ", i)
  10.          rwm.RUnlock()
  11.          fmt.Println("unlocked for reading ", i)
  12.       }(i)
  13.    }
  14.    time.Sleep(time.Millisecond * 1000)
  15.    fmt.Println("try to lock for writing")
  16.    rwm.Lock()
  17.    fmt.Println("locked for writing")
  18. }

上面的示例创建了三个协程用于对读写锁的读锁定与读解锁操作。在 rwm.Lock()种会对main中协程进行写锁定，但是for循环中的读解锁尚未完成，因此会造成mian中的协程阻塞。当for循环中的读解锁操作都完成后就会试图唤醒main中阻塞的协程，main中的写锁定才会完成。输出结果如下

  1. try to lock read  0
  2. get locked  0
  3. try to lock read  2
  4. get locked  2
  5. try to lock read  1
  6. get locked  1
  7. try to lock for writing
  8. try to unlock for reading  0
  9. unlocked for reading  0
  10. try to unlock for reading  2
  11. unlocked for reading  2
  12. try to unlock for reading  1
  13. unlocked for reading  1
  14. locked for writing