Go 互斥

上面的例子中，我们看过了如何在多个协程之间原子地访问计数器，对于更复杂的例子，我们可以使用Mutex来在多个协程之间安全地访问数据。

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "runtime"
  7.     "sync"
  8.     "sync/atomic"
  9.     "time"
  10. )
  12. func main() {
  14.     // 这个例子的状态就是一个map
  15.     var state = make(map[int]int)
  17.     // 这个`mutex`将同步对状态的访问
  18.     var mutex = &sync.Mutex{}
  20.     // ops将对状态的操作进行计数
  21.     var ops int64 = 0
  22.     // 这里我们启动100个协程来不断地读取这个状态
  23.     for r := 0; r < 100; r++ {
  24.         go func() {
  25.             total := 0
  26.             for {
  28.                 // 对于每次读取，我们选取一个key来访问，
  29.                 // mutex的`Lock`函数用来保证对状态的
  30.                 // 唯一性访问，访问结束后，使用`Unlock`
  31.                 // 来解锁，然后增加ops计数器
  32.                 key := rand.Intn(5)
  33.                 mutex.Lock()
  34.                 total += state[key]
  35.                 mutex.Unlock()
  36.                 atomic.AddInt64(&ops, 1)
  38.                 // 为了保证这个协程不会让调度器出于饥饿状态，
  39.                 // 我们显式地使用`runtime.Gosched`释放了资源
  40.                 // 控制权，这种控制权会在通道操作结束或者
  41.                 // time.Sleep结束后自动释放。但是这里我们需要
  42.                 // 手动地释放资源控制权
  43.                 runtime.Gosched()
  44.             }
  45.         }()
  46.     }
  47.     // 同样我们使用10个协程来模拟写状态
  48.     for w := 0; w < 10; w++ {
  49.         go func() {
  50.             for {
  51.                 key := rand.Intn(5)
  52.                 val := rand.Intn(100)
  53.                 mutex.Lock()
  54.                 state[key] = val
  55.                 mutex.Unlock()
  56.                 atomic.AddInt64(&ops, 1)
  57.                 runtime.Gosched()
  58.             }
  59.         }()
  60.     }
  62.     // 主协程Sleep，让那10个协程能够运行一段时间
  63.     time.Sleep(time.Second)
  65.     // 输出总操作次数
  66.     opsFinal := atomic.LoadInt64(&ops)
  67.     fmt.Println("ops:", opsFinal)
  69.     // 最后锁定并输出状态
  70.     mutex.Lock()
  71.     fmt.Println("state:", state)
  72.     mutex.Unlock()
  73. }

运行结果

  1. ops: 3931611
  2. state: map[0:84 2:20 3:18 1:65 4:31]