例行公事：选择真的选择随机案例吗？

Question

上下文：https://tour.golang.org/concurrency/5

大家好，我正在按照上面的链接学习 Go。

描述说“如果有多个准备好，它会随机选择一个。” 但是，在使主程序等待 2 秒后，在调用 func fibonacci 之前。 2 秒后通道应如下所示： c: 10 次调用以从渠道获取价值 退出：0

在我看来，两个频道都准备好了。如果“如果多个都准备好了，它会随机选择一个”为真，那么斐波那契案例中的第一个调用将有 50% 的机会从退出通道中获得 0。然而，事实并非如此。在退出之前，所有 10 个数字都会被打印出来。因此，看起来选择不是随机的。我错过了什么吗？

package main

import "fmt"
import "time"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    time.Sleep(2 * time.Second)
    fibonacci(c, quit)
}

另外，下一页： https://tour.golang.org/concurrency/6

看起来默认代码应该打印出任何一个勾号。或繁荣！在 500 毫秒。然而，只有BOOM！总是打印出来的。如果我将默认时间从 50 更改为 55，则刻度和 BOOM 都会被打印。为什么是这样？在选择中，After 是否优先于 Tick？

package main

import (
    "fmt"
    "time"
)

func main() {
    tick := time.Tick(100 * time.Millisecond)
    boom := time.After(500 * time.Millisecond)
    for {
        select {
        case <-tick:
            fmt.Println("tick.")
        case <-boom:
            fmt.Println("BOOM!")
            return
        default:
            fmt.Println("    .")
            time.Sleep(55 * time.Millisecond)
        }
    }
}

Answer 1

我认为您对主要方法中发生的事情有误...为了清楚起见，我将分解我认为发生的事情

func main() {
c := make(chan int)
quit := make(chan int) // make a couple channels
go func() {
    for i := 0; i < 10; i++ {
        fmt.Println(<-c) // blocked here in goroutine
    }
    quit <- 0
}() // go func { ... }() - you're both writing this closure and invoking it as a goroutine
time.Sleep(2 * time.Second) // sleep for 2 seconds
fibonacci(c, quit) // call fibonacci passing in the channels
}

所以这里实际发生的情况是，您已将此闭包称为 goroutine，然后等待 2 秒，在此期间您的 goroutine 仍在 for 循环的主体中等待接收 c，您调用 fibonacci像你期望的那样执行进入for-select，此时你在循环的每次迭代c <- x 上继续点击该代码（它接收，我被递增，你再次接收，下一个值，直到循环结束，因为我== 10）。然后您继续下一行并在退出通道上发送，选择执行该条件并且您的程序退出。

就语言规范所说的首先执行的内容而言；

“选择”语句的执行分几个步骤进行：

1) 对于语句中的所有情况，receive 的通道操作数 操作以及 send 的通道和右侧表达式 语句在输入时按源顺序只计算一次 “选择”语句。结果是一组要接收的通道 from 或 send to，以及要发送的相应值。任何一方 无论哪种情况（如果有），该评估中的影响都会发生 选择通讯操作继续。上的表达 带有短变量声明的 RecvStmt 的左侧或 任务尚未评估。 2) 如果其中一项或多项 通信可以继续，选择一个可以继续的 通过统一的伪随机选择。否则，如果有 默认情况下，选择该情况。如果没有默认情况，则 “选择”语句块，直到至少有一个通信可以 继续。除非所选案例是默认案例，否则相应的 执行通讯操作。 3) 如果所选案例是 带有短变量声明或赋值的 RecvStmt， 评估左侧表达式并接收到值（或 值）被分配。 4) 所选案例的陈述清单为 执行。

在竞态条件下它只是伪随机，问题是你没有创建竞态条件。

Answer 2

在代码的第一个 sn-p 中，quit 在 for 循环之前永远不会准备好。而且，在循环的每次迭代中，c 都已准备就绪，并且会阻塞直到发送一个数字。所以select 真的无能为力，只能写信给c。睡两秒也没关系。

第二段代码没有错误。 select 确实随机选择了一个案例。但是，Go Playground 有一个固定的随机生成器，这意味着在 Playground 上，每次运行时 select 总是会选择一个特定的情况。

Answer 3

您创建了一个无缓冲的chan：

c := make(chan int)

这意味着从 chan 读取的任何内容都将被阻塞，直到有内容写入为止。任何写入 chan 的东西都会被阻塞，直到有东西从中读取。

因此在这段代码中：

    for i := 0; i < 10; i++ {
        fmt.Println(<-c)
    }
    quit <- 0

<-c 会阻塞，直到有东西放在 c 上。所以它就在那里等到你的time.Sleep() 完成之后，然后到达：

    case c <- x:

在此之后，它交替阻塞来回读取一个值，写入一个值，直到它读取 10 个值，然后将 0 发送到 quit。

 

要创建缓冲通道，您需要指定缓冲区的大小。

c := make(chan int, 10)

但请注意，即使您这样做，它仍然不会像您预期的那样运行，因为您在写入 quit 之前会读取所有 10 个值。你需要把作者放在同一个地方，读者放在同一个地方，而不是把它们混在一起。