1. 并发安全和锁

有时候在Go代码中可能会存在多个goroutine同时操作一个资源（临界区），这种情况会发生竞态问题（数据竞态）。类比现实生活中的例子有十字路口被各个方向的的汽车竞争；还有火车上的卫生间被车厢里的人竞争。

举个例子：

  1. var x int64
  2. var wg sync.WaitGroup
  4. func add() {
  5.     for i := 0; i < 5000; i++ {
  6.         x = x + 1
  7.     }
  8.     wg.Done()
  9. }
  10. func main() {
  11.     wg.Add(2)
  12.     go add()
  13.     go add()
  14.     wg.Wait()
  15.     fmt.Println(x)
  16. }

上面的代码中我们开启了两个goroutine去累加变量x的值，这两个goroutine在访问和修改x变量的时候就会存在数据竞争，导致最后的结果与期待的不符。

1.1.1. 互斥锁

互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。Go语言中使用sync包的Mutex类型来实现互斥锁。 使用互斥锁来修复上面代码的问题：

  1. var x int64
  2. var wg sync.WaitGroup
  3. var lock sync.Mutex
  5. func add() {
  6.     for i := 0; i < 5000; i++ {
  7.         lock.Lock() // 加锁
  8.         x = x + 1
  9.         lock.Unlock() // 解锁
  10.     }
  11.     wg.Done()
  12. }
  13. func main() {
  14.     wg.Add(2)
  15.     go add()
  16.     go add()
  17.     wg.Wait()
  18.     fmt.Println(x)
  19. }

使用互斥锁能够保证同一时间有且只有一个goroutine进入临界区，其他的goroutine则在等待锁；当互斥锁释放后，等待的goroutine才可以获取锁进入临界区，多个goroutine同时等待一个锁时，唤醒的策略是随机的。

1.1.2. 读写互斥锁

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。读写锁在Go语言中使用sync包中的RWMutex类型。

读写锁分为两种：读锁和写锁。当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁会继续获得锁，如果是获取写锁就会等待；当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是写锁都会等待。

读写锁示例：

  1. var (
  2.     x      int64
  3.     wg     sync.WaitGroup
  4.     lock   sync.Mutex
  5.     rwlock sync.RWMutex
  6. )
  8. func write() {
  9.     // lock.Lock()   // 加互斥锁
  10.     rwlock.Lock() // 加写锁
  11.     x = x + 1
  12.     time.Sleep(10 * time.Millisecond) // 假设读操作耗时10毫秒
  13.     rwlock.Unlock()                   // 解写锁
  14.     // lock.Unlock()                     // 解互斥锁
  15.     wg.Done()
  16. }
  18. func read() {
  19.     // lock.Lock()                  // 加互斥锁
  20.     rwlock.RLock()               // 加读锁
  21.     time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
  22.     rwlock.RUnlock()             // 解读锁
  23.     // lock.Unlock()                // 解互斥锁
  24.     wg.Done()
  25. }
  27. func main() {
  28.     start := time.Now()
  29.     for i := 0; i < 10; i++ {
  30.         wg.Add(1)
  31.         go write()
  32.     }
  34.     for i := 0; i < 1000; i++ {
  35.         wg.Add(1)
  36.         go read()
  37.     }
  39.     wg.Wait()
  40.     end := time.Now()
  41.     fmt.Println(end.Sub(start))
  42. }

需要注意的是读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来。