【Go语言核心手册9】互斥锁

往期精选（欢迎转发~~）

• 如何看待程序员35岁职业危机？

• Java全套学习资料（14W字），耗时半年整理

• 我肝了三个月，为你写出了GO核心手册

• 消息队列：从选型到原理，一文带你全部掌握

• 肝了一个月的ETCD，从Raft原理到实践

• 更多...

​9.1 基础知识

对写操作的锁定和解锁，简称“写锁定”和“写解锁”： 

func (*RWMutex)Lock() func (*RWMutex)Unlock()

对读操作的锁定和解锁，简称为“读锁定”与“读解锁”： 

func (*RWMutex)RLock() func (*RWMutex)RUnlock()

看个不使用锁的示例：

func printer(str string) {   for _, data := range str {      fmt.Printf("%c", data)   }   fmt.Println()}func person1() {   printer("hello")}func person2() {   printer("world")}func main() {   go person1()   person2()time.Sleep(time.Second)}//输出结果//worhello//ld

加上互斥锁的示例：

var mut sync.Mutexfunc printer(str string) {   mut.Lock()   defer mut.Unlock()   for _, data := range str {      fmt.Printf("%c", data)   }   fmt.Println()}func person1() {   printer("hello")}func person2() {   printer("world")}func main() {   go person1()   person2()time.Sleep(time.Second)}//输出结果//world//hello

9.2 注意事项

9.2.1 互斥锁

• 不要重复锁定互斥锁：对一个已经被锁定的互斥锁进行锁定，是会立即阻塞当前的goroutine，这个 goroutine所执行的流程，会一直停滞在调用该互斥锁的Lock方法的那行代码上。（注意：这种由 Go 语言运行时系统自行抛出的 panic 都属于致命错误，都是无法被恢复的，调用recover函数对它们起不到任何作用。也就是说，一旦产生死锁，程序必然崩溃。）

• 不要忘记解锁互斥锁，必要时使用defer语句：因为在一个 goroutine 执行的流程中，可能会出现诸如“锁定、解锁、再锁定、再解锁”的操作，所以如果我们忘记了中间的解锁操作，那就一定会造成重复锁定。

var mutex sync.Mutex    func write() {     defer mutex.Unlock() // 通过defer解锁    mutex.Lock()     // 获取临界资源，执行具体逻辑... }

• 不要对尚未锁定或者已解锁的互斥锁解锁：这个程序会直接panic。

var mutex sync.Mutex // 定义互斥锁变量 mutexmutex.Lock()mutex.Unlock()mutex.Unlock() // fatal error: sync: unlock of unlocked mutexreturn

• 不要在多个函数之间直接传递互斥锁：互斥锁是一结构体类型，即值类型，把它传给一个函数、将它从函数中返回、把它赋给其他变量、让它进入某个通道都会导致它的副本的产生。因此，原值和它的副本、以及多个副本之间都是完全独立的，它们都是不同的互斥锁。

9.2.2 读写锁

• 在写锁已被锁定的情况下再试图锁定写锁，会阻塞当前的 goroutine；

• 在写锁已被锁定的情况下试图锁定读锁，也会阻塞当前的 goroutine；

• 在读锁已被锁定的情况下试图锁定写锁，同样会阻塞当前的 goroutine；

• 在读锁已被锁定的情况下再试图锁定读锁，并不会阻塞当前的 goroutine；

• 解锁“读写锁中未被锁定的写锁”，会立即引发 panic，对于读锁也是如此。

上面写的有点啰嗦，我用大白话总结一下：我读数据时，你可以去读，因为我两的数据是一样的；我读数据时，你不能写，你写了，数据就变了，我还读个鬼啊；我写数据时，你不能读，也不能写，我就是这么强势。下面看一个实例：

var count intvar mutex sync.RWMutexfunc write(n int) {   rand.Seed(time.Now().UnixNano())   fmt.Printf("写 goroutine %d 正在写数据...\n", n)   mutex.Lock()   num := rand.Intn(500)   count = num   fmt.Printf("写 goroutine %d 写数据结束，写入新值 %d\n", n, num)   mutex.Unlock()}func read(n int) {   mutex.RLock()   fmt.Printf("读 goroutine %d 正在读取数据...\n", n)   num := count   fmt.Printf("读 goroutine %d 读取数据结束，读到 %d\n", n, num)   mutex.RUnlock()}func main() {   for i := 0; i < 10; i++ {      go read(i + 1)   }   for i := 0; i < 10; i++ {      go write(i + 1)   }   time.Sleep(time.Second*5)}//输出结果读 goroutine 1 正在读取数据...读 goroutine 1 读取数据结束，读到 0读 goroutine 7 正在读取数据...读 goroutine 7 读取数据结束，读到 0读 goroutine 3 正在读取数据...读 goroutine 3 读取数据结束，读到 0读 goroutine 10 正在读取数据...读 goroutine 10 读取数据结束，读到 0读 goroutine 8 正在读取数据...读 goroutine 8 读取数据结束，读到 0读 goroutine 6 正在读取数据...读 goroutine 5 正在读取数据...读 goroutine 5 读取数据结束，读到 0写 goroutine 2 正在写数据...读 goroutine 4 正在读取数据...读 goroutine 4 读取数据结束，读到 0写 goroutine 4 正在写数据...写 goroutine 3 正在写数据...读 goroutine 2 正在读取数据...读 goroutine 2 读取数据结束，读到 0写 goroutine 9 正在写数据...读 goroutine 6 读取数据结束，读到 0写 goroutine 7 正在写数据...读 goroutine 9 正在读取数据...读 goroutine 9 读取数据结束，读到 0写 goroutine 6 正在写数据...写 goroutine 1 正在写数据...写 goroutine 8 正在写数据...写 goroutine 10 正在写数据...写 goroutine 5 正在写数据...写 goroutine 2 写数据结束，写入新值 365写 goroutine 4 写数据结束，写入新值 47写 goroutine 3 写数据结束，写入新值 468写 goroutine 9 写数据结束，写入新值 155写 goroutine 7 写数据结束，写入新值 112写 goroutine 6 写数据结束，写入新值 490写 goroutine 1 写数据结束，写入新值 262写 goroutine 8 写数据结束，写入新值 325写 goroutine 10 写数据结束，写入新值 103写 goroutine 5 写数据结束，写入新值 353

可以看出前面10个协程可以并行读取数据，后面10个协程，就全部阻塞在了“...正在写数据...”过程，等读完了，然后10个协程就开始依次写。

9.3 总结

本章的内容不多，主要需要注意互斥锁和读写锁的几条注意事项，读写锁其实就是更细粒度的锁划分，为了能让程序更好并发，上面已经讲述的非常清楚，这里就不再啰嗦。唯一再强调的一点，无论是互斥锁还是读写锁，我们都不要试图去解锁未锁定的锁，因为这样会引发不可恢复的 panic。