1 读写互斥锁

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。
读写锁分为两种：读锁和写锁。
当一个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. }