go 中睡眠和 select 的行为

Question

我试图更多地了解在 Go 中各种 blocking/waiting 类型的操作期间表面下发生的事情。举个例子：

otherChan = make(chan int)
t = time.NewTicker(time.Second)
for {
    doThings()

    // OPTION A: Sleep
    time.Sleep(time.Second)

    // OPTION B: Blocking ticker
    <- t.C

    // OPTION C: Select multiple
    select {
        case <- otherChan:
        case <- t.C:
    }
}

从低级别的角度来看（系统调用，cpu 调度）这些在等待时有什么区别？

我的理解是 time.Sleep 让 CPU 可以自由执行其他任务，直到指定的时间过去。阻塞代码 <- t.C 是否也这样做？处理器是否轮询通道或是否涉及中断？在 select 中拥有多个频道会改变什么吗？

换句话说，假设 otherChan 从未有过任何投入，这三个选项会以相同的方式执行，还是会比其他选项占用更少的资源？

Answer 1

这是一个非常有趣的问题，所以我 cd 进入我的 Go 源代码开始寻找。

time.Sleep

time.Sleep 定义如下：

// src/time/sleep.go

// Sleep pauses the current goroutine for at least the duration d.
// A negative or zero duration causes Sleep to return immediately.
func Sleep(d Duration)

没有正文，没有 OS-specific time_unix.go 中的定义！？！稍微搜索一下，答案是因为 time.Sleep 实际上是在运行时定义的：

// src/runtime/time.go

// timeSleep puts the current goroutine to sleep for at least ns nanoseconds.
//go:linkname timeSleep time.Sleep
func timeSleep(ns int64) {
  // ...
}

回想起来这很有意义，因为它必须与 goroutine 调度程序交互。它最终调用 goparkunlock，即 "puts the goroutine into a waiting state"。 time.Sleep 创建一个 runtime.timer 并在计时器到期时调用回调函数 - 该回调函数通过调用 goready 唤醒 goroutine。有关 runtime.timer.

的更多详细信息，请参阅下一节

time.NewTicker

time.NewTicker 创建一个 *Ticker（而 time.Tick 是一个辅助函数，它做同样的事情但是直接 returns *Ticker.C，代码的接收通道，而不是 *Ticker，所以你可以用它来编写代码）在运行时有类似的钩子：代码是一个结构，它包含一个 runtimeTimer 和一个用于发送报价信号的通道.

runtimeTimer 在 time 包中定义，但它必须与 src/runtime/time.go 中的 timer 保持同步，因此它实际上是一个 runtime.timer .还记得在 time.Sleep 中，定时器有一个回调函数来唤醒休眠的 goroutine 吗？在 *Ticker 的情况下，定时器的回调函数在代码通道上发送当前时间。

然后，真正的 waiting/scheduling 发生在从通道接收时，这与 select 语句基本相同，除非 otherChan 在 tick 之前发送一些东西，所以让我们看一下阻塞接收发生了什么。

<- 陈

通道在 src/runtime/chan.go 中由 hchan 结构实现（现在在 Go 中！）。 Channel操作有匹配函数，一个receive通过chanrecv:

实现

// chanrecv receives on channel c and writes the received data to ep.
// ep may be nil, in which case received data is ignored.
// If block == false and no elements are available, returns (false, false).
// Otherwise, if c is closed, zeros *ep and returns (true, false).
// Otherwise, fills in *ep with an element and returns (true, true).
func chanrecv(t *chantype, c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
  // ...
}

这部分有很多不同的情况，但在您的示例中，它是来自异步通道的阻塞接收（time.NewTicker 创建一个缓冲区为 1 的通道），但无论如何它最终会调用... goparkunlock，再次允许其他 goroutines 在等待这个 goroutines 时继续。

所以...

在所有情况下，goroutine 最终都会被停放（这并不令人震惊 - 它无法取得进展，因此如果有可用的话，它必须将其线程留给其他 goroutine）。看一眼代码似乎表明通道的开销比直接 time.Sleep 多一点。但是，它允许更强大的模式，例如您示例中的最后一个：goroutine 可以被另一个通道唤醒，以先到者为准。

为了回答您的其他问题，关于轮询，计时器由 goroutine 管理，该 goroutine 会休眠直到其队列中的下一个计时器，因此它仅在知道必须触发计时器时才工作。当下一个计时器到期时，它会唤醒调用 time.Sleep 的 goroutine（或者在 ticker 的通道上发送值，它会执行回调函数所做的任何事情）。

通道中没有轮询，在通道上发送时接收解锁，在 chan.go 文件的 chansend 中：

// wake up a waiting receiver
sg := c.recvq.dequeue()
if sg != nil {
    recvg := sg.g
    unlock(&c.lock)
    if sg.releasetime != 0 {
        sg.releasetime = cputicks()
    }
    goready(recvg, 3)
} else {
    unlock(&c.lock)
}

这是对 Go 源代码的有趣探索，非常有趣的问题！希望我至少回答了一部分！

go 中睡眠和 select 的行为

Behavior of sleep and select in go

resources

go

blocking

time.Sleep

time.NewTicker

<- 陈

所以...