在golang中，实现了两种锁：

  • Mutex，互斥锁
  • RWMutex：读写锁，RWMutex基于Mutex实现

Mutex（互斥锁）

  1. Mutex为互斥锁，Lock()加锁，Unlock()解锁
  2. 在一个goroutine获得Mutex之后，其他goroutine只能等到这个goroutine释放该Mutex
  3. 使用Lock()加锁之后，不能继续对其加锁，知道利用Unlock()解锁之后才能解锁
  4. 在Lock()之前使用Unlock()会导致panic异常
  5. 已经锁定的Mutex并不与特定的goroutine相关联，这样可以利用一个goroutine对其加锁，再利用其他groutine对其解锁
  6. 适用于读写不确定，并且只有一个读或者写的场景

加锁和解锁示例

  1. package main
  3. import (
  4.     "time"
  5.     "fmt"
  6.     "sync"
  7. )
  9. func main() {
  10.     var mutex sync.Mutex
  11.     fmt.Println("Lock the lock")
  12.     mutex.Lock()
  13.     fmt.Println("The lock is locked")
  14.     channels := make([]chan int, 4)
  15.     for i := 0; i < 4; i++ {
  16.         channels[i] = make(chan int)
  17.         go func(i int, c chan int) {
  18.             fmt.Println("Not lock: ", i)
  19.             mutex.Lock()
  20.             fmt.Println("Locked: ", i)
  21.             time.Sleep(time.Second)
  22.             fmt.Println("Unlock the lock: ", i)
  23.             mutex.Unlock()
  24.             c <- i
  25.         }(i, channels[i])
  26.     }
  27.     time.Sleep(time.Second)
  28.     fmt.Println("Unlock the main goroutine lock")
  29.     mutex.Unlock()
  30.     time.Sleep(time.Second)
  32.     for _, c := range channels {
  33.         <-c
  34.     }
  35. }

  1. // 程序输出
  2. Lock the lock
  3. The lock is locked
  4. Not lock:  1
  5. Not lock:  0
  6. Not lock:  2
  7. Not lock:  3
  8. Unlock the main goroutine lock
  9. Locked:  1
  10. Unlock the lock:  1
  11. Locked:  0
  12. Unlock the lock:  0
  13. Locked:  2
  14. Unlock the lock:  2
  15. Locked:  3
  16. Unlock the lock:  3

在解锁之前加锁会导致死锁

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. func main(){
  9.     var mutex sync.Mutex
  10.     mutex.Lock()
  11.     fmt.Println("Locked")
  12.     mutex.Lock()
  13. }
  1. //程序输出
  2. Locked
  3. fatal error: all goroutines are asleep - deadlock!

RWMutex（读写锁）

  1. RWMutex是单写多读锁，该锁可以加多个读锁或者一个写锁
  2. 读锁占用的情况下会阻止写，不会阻止读，多个goroutine可以同时获取读锁
  3. 写锁会阻止其他goroutine（无论读和写进来）进来，整个锁由该goroutine 独占
  4. 适用于读多写少的场景

写锁：Lock() 和 Unlock()

  1. Lock()加写锁，Unlock()解写锁
  2. 如果在加写锁之前已经由其他的读锁或者写锁，则Lock()会阻塞直到该锁可用。已经阻塞的Lock()调用会从获得的锁中排除新的读取器，即写锁的权限高于读锁，有写锁时优先进行写锁定

  3. 在Lock()使用Unlock()会导致panic异常

    读锁：RLock() 和 RUnlock()

  4. Rlock（）加读锁，RUnlock()解读锁

  5. RLock()加读锁时，如果存在写锁，则无法加读锁；当只有读锁或者没有锁时，可以加读锁，读锁可以加载多个
  6. RUnlock()解读锁，Runlock()撤销单次RLock()调用，对于其他同时存在的读锁则没有效果
  7. 在没有读锁的情况下调用Runlock()会导致panic错误

下面展示一下我们的写锁：

  1. // 在这里，我们使用一个
  2. type Handler struct {
  3.     mx         sync.RWMutex
  4.     lastActive time.Time
  5. }
  7. func (h *Handler) Run() {
  8.     h.mx.Lock()
  9.     {
  10.             h.lastActive = time.Now()
  11.     }
  12.     h.mx.Unlock()
  13. }

总结一下：互斥锁定就是单读单写，只能有一种状态；而读写锁则是可以用读锁和写锁，写锁的优先级别高于读锁。

参考: golang 中 sync.Mutex 和 sync.RWMutex