27. 互斥锁与读写锁

Golang 锁

Go中锁分为两种：

• 互斥锁
• 读写锁

互斥锁

并发程序对公共资源访问的限制最常见的就是使用互斥锁的方式。在Go中，sync.Mutex 提供了互斥锁的实现。

简单使用示例：

func main() {
var mutex sync.Mutex
count := 0

for r := 0; r < 50; r++ {
   go func() {
           mutex.Lock()
           count += 1
           mutex.Unlock()
       }()
   }

   time.Sleep(time.Second)
   fmt.Println("the count is : ", count)
}

当执行了 mutex.Lock() 操作后，如果有另外一个 goroutine 又执行了上锁操作，那么该操作被被阻塞，直到该互斥锁恢复到解锁状态。

读写锁

顾名思义，读写锁是对读写操作进行加锁。需要注意的是多个读操作之间不存在互斥关系，这样提高了对共享资源的访问效率。

Go中读写锁由 sync.RWMutex 提供，主要包括：

- func (rw *RWMutex) Lock()

- func (rw *RWMutex) RLock()

- func (rw *RWMutex) RLocker() Locker

- func (rw *RWMutex) RUnlock()

- func (rw *RWMutex) Unlock()

其中 Lock() 即“写锁定”，调用了“写锁定”后，不能有其他goroutine进行读或者写操作。 Unlock() 即“写解锁”，调用了“写解锁”后会唤醒所有因为要进行“读锁定（即:RLock()）” 而被阻塞的 goroutine。

RLock()为“读锁定”，调用“读锁定”后，不能有其他goroutine进行写操作，但是可以进行读操作。RUnlock() 为“读解锁”，调用“读解锁”后，会唤醒一个因为要进行“写锁定”而被阻塞的goroutine。

简单使用示例：

package main

import (
"fmt"
"sync"
"time"
)

func main() {
    var mutex sync.RWMutex
    arr := []int{1, 2, 3}
    go func() {
       fmt.Println("Try to lock writing operation.")
       mutex.Lock()
       fmt.Println("Writing operation is locked.")

       arr = append(arr, 4)

       fmt.Println("Try to unlock writing operation.")
       mutex.Unlock()
       fmt.Println("Writing operation is unlocked.")
   }()

   go func() {
       fmt.Println("Try to lock reading operation.")
       mutex.RLock()
       fmt.Println("The reading operation is locked.")

       fmt.Println("The len of arr is : ", len(arr))

       fmt.Println("Try to unlock reading operation.")
       mutex.RUnlock()
       fmt.Println("The reading operation is unlocked.")
   }()

   time.Sleep(time.Second * 2)
   return
}

运行以上示例，观察输出结果，你将能够比较直观的感受到读写锁的作用。

Ref：https://studygolang.com/articles/11703