Go 状态协程

在上面的例子中，我们演示了如何通过使用mutex来在多个协程之间共享状态。另外一种方法是使用协程内置的同步机制来实现。这种基于通道的方法和Go的通过消息共享内存，保证每份数据为单独的协程所有的理念是一致的。

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "sync/atomic"
  7.     "time"
  8. )
  10. // 在这个例子中，将有一个单独的协程拥有这个状态。这样可以
  11. // 保证这个数据不会被并行访问所破坏。为了读写这个状态，其
  12. // 他的协程将向这个协程发送信息并且相应地接受返回信息。
  13. // 这些`readOp`和`writeOp`结构体封装了这些请求和回复
  14. type readOp struct {
  15.     key  int
  16.     resp chan int
  17. }
  18. type writeOp struct {
  19.     key  int
  20.     val  int
  21.     resp chan bool
  22. }
  24. func main() {
  26.     // 我们将计算我们执行了多少次操作
  27.     var ops int64 = 0
  29.     // reads和writes通道将被其他协程用来从中读取或写入数据
  30.     reads := make(chan *readOp)
  31.     writes := make(chan *writeOp)
  33.     // 这个是拥有`state`的协程，`state`是一个协程的私有map
  34.     // 变量。这个协程不断地`select`通道`reads`和`writes`，
  35.     // 当有请求来临的时候进行回复。一旦有请求，首先执行所
  36.     // 请求的操作，然后给`resp`通道发送一个表示请求成功的值。
  37.     go func() {
  38.         var state = make(map[int]int)
  39.         for {
  40.             select {
  41.             case read := <-reads:
  42.                 read.resp <- state[read.key]
  43.             case write := <-writes:
  44.                 state[write.key] = write.val
  45.                 write.resp <- true
  46.             }
  47.         }
  48.     }()
  50.     // 这里启动了100个协程来向拥有状态的协程请求读数据。
  51.     // 每次读操作都需要创建一个`readOp`，然后发送到`reads`
  52.     // 通道，然后等待接收请求回复
  53.     for r := 0; r < 100; r++ {
  54.         go func() {
  55.             for {
  56.                 read := &readOp{
  57.                     key:  rand.Intn(5),
  58.                     resp: make(chan int)}
  59.                 reads <- read
  60.                 <-read.resp
  61.                 atomic.AddInt64(&ops, 1)
  62.             }
  63.         }()
  64.     }
  66.     // 我们开启10个写协程
  67.     for w := 0; w < 10; w++ {
  68.         go func() {
  69.             for {
  70.                 write := &writeOp{
  71.                     key:  rand.Intn(5),
  72.                     val:  rand.Intn(100),
  73.                     resp: make(chan bool)}
  74.                 writes <- write
  75.                 <-write.resp
  76.                 atomic.AddInt64(&ops, 1)
  77.             }
  78.         }()
  79.     }
  81.     // 让协程运行1秒钟
  82.     time.Sleep(time.Second)
  84.     // 最后输出操作数量ops的值
  85.     opsFinal := atomic.LoadInt64(&ops)
  86.     fmt.Println("ops:", opsFinal)
  87. }

运行结果

  1. ops: 880578

运行这个程序，我们会看到基于协程的状态管理每秒可以处理800, 000个操作。对于这个例子来讲，基于协程的方法比基于mutex的方法更加复杂一点。当然在某些情况下还是很有用的。例如你有很多复杂的协程，而且管理多个mutex可能导致错误。
当然你可以选择使用任意一种方法，只要你保证这种方法让你觉得很舒服而且也能保证程序的正确性。