通过goroutine共享内存

本主题的最后一小节说明了如何使用专用的goroutine共享数据。尽管，共享内存是线程间彼此通信的传统方法，但 Go 具有内置的同步功能，允许单个 goroutine 拥有共享数据。这意味着其他 goroutines 必须发送消息给这个拥有共享数据的单独 goroutine，这可以防止数据损坏。这样的 goroutine 叫 监视器 goroutine。这 Go 的术语中，这是通过通信来共享而不是通过共享来通信。

该技术通过使用 monitor.go 源文件来说明，分五部分来介绍。monitor.go 程序使用监视器 goroutine 随机产生数字。

monitor.go 的第一部分如下：

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "os"
  7.     "strconv"
  8.     "sync"
  9.     "time"
  10. )
  12. var readValue = make(chan int)
  13. var writeValue = make(chan int)

readValue 管道用于读取随机数，而 writeValue 管道用于得到新随机数。

monitor.go 的第二段代码如下：

  1. func set(newValue int) {
  2.     writeValue <-newValue
  3. }
  5. func read() int {
  6.     return <-readValue
  7. }

set() 函数的目的是共享变量的值，而 read() 函数的目的是读取已保存变量的值。

monitor.go 程序的第三段代码如下：

  1. func monitor() {
  2.     var value int
  4.     for {
  5.         select {
  6.             case newValue := <-writeValue:
  7.                 value = newValue
  8.                 fmt.Printf("%d", value)
  9.             case readValue <- value:
  10.         }
  11.     }
  12. }

这个程序的所有逻辑都在这个 monitor() 函数里了。最具体地说，select 语句编排了整个程序的操作。当您有读请求时，read() 函数试图从由 monitor() 函数控制的 readValue 管道读取数据。返回保存在 value 变量中的当前值。另一方面，当您想要修改存储值时，可以调用 set()。往 writeValue 管道写数据也由 select 语句处理。结果就是，不使用 monitor() 函数没人可以处理 value 共享变量。

monitor.go 的第四部分代码如下：

  1. func main() {
  2.     if len(os.Args) != 2 {
  3.         fmt.Println("Please give an integer!")
  4.         return
  5.     }
  6.     n, err := strconv.Atoi(os.Args[1])
  7.     if err != nil {
  8.         fmt.Println(err)
  9.         return
  10.     }
  12.     fmt.Printf("Going to create %d random numbers.\n", n)
  13.     rand.Seed(time.Now().Unix())
  14.     go monitor()

monitor.go 的最后一段代码如下：

  1.     var w sync.WaitGroup
  2.     for r := 0; r < n; r++ {
  3.         w.Add(1)
  4.         go func() {
  5.             defer w.Done()
  6.             set(rand.Intn(10 * n))
  7.         }()
  8.     }
  9.     w.Wait()
  10.     fmt.Printf("\nLast value: %d\n", read())
  11. }

执行 monitor.go 产生如下输出：

  1. $go run monitor.go 20
  2. Going to create 20 random numbers.
  3. 89 88 166 42 149 89 20 84 44 178 184 28 52 121 62 91 31c117 140 106
  4. Last value: 106
  5. $go run monitor.go 10
  6. Going to create 10 random numbers.
  7. 30 16 66 70 65 45 31 57 62 26
  8. Last value: 26

个人而言，我更喜欢使用监视器 goroutine 而不是传统的共享内存技术，因为使用监视器 goroutine 的实现更安全，更贴合 Go 的哲学思想