我在研究并发和缓冲 channel 时遇到了以下让我感到困惑的问题: https://play.golang.org/p/wir7wP2u-yf

1. 为什么函数 echo 中 channel (大小为 3)的“卸载”会发生在包含 4 的情况下？

2. 为什么5发送到 channel c后， channel 容量一直为0？

3. 为什么没有回显 10？

package main

import "fmt"

func echo(c chan int) {
    for num := range c {
        //fmt.Printf("length of channel c: %v\n",len(c))
        fmt.Println(num)
    }
    fmt.Println("Done iterating")
}

func main() {
    fmt.Println("main() started")
    c := make(chan int, 3)

    go echo(c)

    c <- 1
    fmt.Printf("After 1, capacity %v\n",len(c))
    c <- 2
    fmt.Printf("After 2, capacity %v\n",len(c))
    c <- 3
    fmt.Printf("After 3, capacity %v\n",len(c))
    c <- 4 // blocks here
    fmt.Printf("After 4, capacity %v\n",len(c))
    c <- 5
    fmt.Printf("After 5, capacity %v\n",len(c))
    c <- 6
    fmt.Printf("After 6, capacity %v\n",len(c))
    c <- 7
    fmt.Printf("After 7, capacity %v\n",len(c))
    c <- 8
    fmt.Printf("After 8, capacity %v\n",len(c))
    c <- 9
    fmt.Printf("After 9, capacity %v\n",len(c))
    c <- 10
    fmt.Printf("After 10\n")
    fmt.Println("main() stopped")
}

最佳答案

这完全取决于操作系统的调度。上述代码的结果并不总是相同的。

main() started
After 1, capacity 1
After 2, capacity 2
After 3, capacity 3
1
2
3
4
After 4, capacity 0
After 5, capacity 0
After 6, capacity 1
After 7, capacity 2
After 8, capacity 3
5
6
7
8
9
After 9, capacity 0
After 10
main() stopped

这个结果可能和你在 Playground 上看到的一样。但是，这是不可预测的，因为我们无法确定操作系统如何安排 goroutine 的执行顺序。

如果我在我的本地机器上运行这段代码，每次执行它都会不同。见下文:

第一次运行

main() started
After 1, capacity 1
After 2, capacity 1
After 3, capacity 2
1
2
3
4
After 4, capacity 3
After 5, capacity 0
5
After 6, capacity 0
After 7, capacity 1
After 8, capacity 2
After 9, capacity 3
6
7
8
9
10
After 10
main() stopped

第二次运行

main() started
After 1, capacity 1
After 2, capacity 2
1
2
3
After 3, capacity 2
After 4, capacity 0
4
5
After 5, capacity 1
After 6, capacity 0
After 7, capacity 1
After 8, capacity 2
6
7
8
9
After 9, capacity 3
After 10
main() stopped
10

所以你的问题的答案是

1. 接收 channel (for 4)刚刚在 main 函数中的 fmt.Printf 之前执行。每次执行都可能不同。在您的本地计算机上尝试。

2. 和1类似，只是在len(c)之前按range读取。

3. 主协程在从 channel 读取 10 之前退出。在这种情况下，您应该使用一些技术等待 channel 中的所有项目被读取，例如时间休眠、同步包的 WaitGroup 或其他 channel 。

您可以通过在要检查的行之间插入 time.Sleep(time.Second) 来查看该程序的工作方式。

例如，如果您在 fmt.Println("main() stopped") 之前 sleep 1 秒，您总是可以看到 10 回显，因为主 goroutine将等待一秒钟。 (1 秒足以从 channel 中读取一个项目)

package main

import "fmt"
import "time"

func echo(c chan int) {
    for num := range c {
        fmt.Println(num)
    }
    fmt.Println("Done iterating")
}

func main() {
    fmt.Println("main() started")
    c := make(chan int, 3)

    go echo(c)

    c <- 1
    fmt.Printf("After 1, capacity %v\n",len(c))
    c <- 2
    fmt.Printf("After 2, capacity %v\n",len(c))
    c <- 3
    fmt.Printf("After 3, capacity %v\n",len(c))
    c <- 4 // blocks here
    fmt.Printf("After 4, capacity %v\n",len(c))
    c <- 5
    fmt.Printf("After 5, capacity %v\n",len(c))
    c <- 6
    fmt.Printf("After 6, capacity %v\n",len(c))
    c <- 7
    fmt.Printf("After 7, capacity %v\n",len(c))
    c <- 8
    fmt.Printf("After 8, capacity %v\n",len(c))
    c <- 9
    fmt.Printf("After 9, capacity %v\n",len(c))
    c <- 10
    fmt.Printf("After 10\n")
    time.Sleep(time.Second)
    fmt.Println("main() stopped")
}

关于go - 从 goroutine 中的缓冲 channel 读取时的执行顺序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55164733/