Go语言核心手册-9.互斥锁

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.Mutex
func 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 // 定义互斥锁变量 mutex
mutex.Lock()
mutex.Unlock()
mutex.Unlock() // fatal error: sync: unlock of unlocked mutex
return

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

9.2.2 读写锁

• 在写锁已被锁定的情况下再试图锁定写锁，会阻塞当前的 goroutine；
• 在写锁已被锁定的情况下试图锁定读锁，也会阻塞当前的 goroutine；
• 在读锁已被锁定的情况下试图锁定写锁，同样会阻塞当前的 goroutine；
• 在读锁已被锁定的情况下再试图锁定读锁，并不会阻塞当前的 goroutine；
• 解锁“读写锁中未被锁定的写锁”，会立即引发 panic，对于读锁也是如此。

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

var count int
var mutex sync.RWMutex
func 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。