为什么发送到通道的消息会被覆盖？

在 Go 语言中，发送到通道的消息可能会被覆盖，这是由于数据争用造成的。当多个 goroutine 并发地读写共享内存时，如果没有适当的同步机制，就会发生数据争用。为了避免这种情况，需要确保只允许一个 goroutine同时访问共享数据。 一个常见的解决方法是使用别名安全的类型，如一字节数组 ([1]byte) 而不是切片，因为切片上的操作不是并发安全的。另外，可以简化生成器和消费者函数的 API，使其同步，并关闭通道以允许程序正确终止。

golang 中一个非常简单且常见的情况如下，但得到的结果不是预期的。

package main

import (
    "fmt"
    "time"
)

func main() {
    consumer(generator())
    for {
        time.sleep(time.duration(time.second))
    }
}

// simple generator through channel
func generator() <-chan []byte {
    ret := make(chan []byte)
    go func() {
        // make buf outside of loop, and result is not expected
        var ch = byte('a')
        count := 0
        buf := make([]byte, 1)
        for {
            if count > 10 {
                return
            }
            // make buf inside loop, and result is expected
            // buf := make([]byte, 1)
            buf[0] = ch
            ret <- buf
            ch++
            count++
            // time.sleep(time.duration(time.second))
        }
    }()
    return ret
}

// simple consumer through channel
func consumer(recv <-chan []byte) {
    go func() {
        for buf := range recv {
            fmt.println("received:" + string(buf[0]))
        }
    }()
}

输出： 收到一个 收到：b 收到：d 收到：d 收到：f 收到：f 收到：h 收到：h 收到：j 收到：j 已收到：k

在生成器中，如果将 buf 变量放入 for 循环中，结果就是我所期望的：

received:A
received:B
received:C
received:D
received:E
received:F
received:G
received:H
received:I
received:J
received:K

我想即使buf在for循环之外并且并不总是改变，在我们将其写入channe之后，接收器将读出它直到下一次写入发生，所以它的内容不应该被覆盖，但看起来golang行为不是这样一来，这里到底出了什么问题呢？

正确答案

问题：您的代码包含数据争用

将程序保存在名为 main.go 的文件中；然后使用 the race detector 运行它：go run -race main.go。您应该看到类似以下内容：

$ go run -race main.go 
received:a
==================
warning: data race
write at 0x00c000180000 by goroutine 7:
  main.generator.func1()
      /redacted/main.go:29 +0x8c

previous read at 0x00c000180000 by goroutine 8:
  main.consumer.func1()
      /redacted/main.go:43 +0x55

竞争检测器告诉您，您的程序包含数据竞争，因为两个 goroutine 在没有同步的情况下写入和读取某些共享内存：

• 在 generator 函数中作为 goroutine 启动的匿名函数在第 29 行更新其名为 buf 的局部变量；
• 作为 consumer 函数中的 goroutine 启动的匿名函数从第 43 行的名为 buf 的局部变量读取。

数据竞争源于两件事的结合：

1. 虽然 consumer 中的局部变量 consumer 只是 generator 中同名局部变量的副本，但这些切片变量是耦合的，因为它们引用相同的底层数组。

   参见[语言规范的相关部分](https://golang.org/ref/spec#Slice_types)：

2. 切片上的操作不是并发安全的，如果并发执行（即同时从多个 goroutine 执行），则需要适当的同步。

您的代码显示的是别名的典型情况。您应该更好地熟悉 how slices work。

解决方案

您可以通过使用一字节数组 ([1]byte) 而不是切片来消除数据竞争，但数组在 go 中非常不灵活。目前尚不清楚您是否真的需要使用字节片。由于您一次实际上只向通道发送一个字节，为什么不简单地使用 chan byte 而不是 chan []byte 呢？

与数据竞争无关的其他改进包括：

• 修改两个函数的 api，使它们同步（因此更容易推理）；

• 简化生成器逻辑并关闭通道，以便 main 可以真正终止；

• 简化消费者逻辑并且不为其生成 goroutine。

  package main
  
  import "fmt"
  
  func main() {
      ch := make(chan byte)
      go generator(ch)
      consumer(ch)
  }
  
  func generator(ch chan<- byte) {
      var c byte = 'A'
      for i := 0; i < 10; i++ {
          ch <- c
          c++
      }
      close(ch)
  }
  
  func consumer(ch <-chan byte) {
      for c := range ch {
          fmt.Printf("received: %c\n", c)
      }
  }

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。