go - go 中的 sleep 和 select 行为

Question

我试图更多地了解 Go 中各种阻塞/等待类型操作期间在表面下发生的情况。举个例子:

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照着做？处理器正在轮询 channel 还是涉及中断？选择多个 channel 会改变什么吗？

换句话说，假设 otherChan从来没有放入任何东西，这三个选项是否会以相同的方式执行，或者其中一个选项会比其他选项占用更少的资源？

Answer 1

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

时间. 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)

在特定于操作系统的 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，这“将 goroutine 置于等待状态”。 time.Sleep 创建一个带有回调函数的 runtime.timer，该函数在计时器到期时调用 - 该回调函数通过调用 goready 唤醒 goroutine >。有关 runtime.timer 的更多详细信息，请参阅下一节。

时间.NewTicker

time.NewTicker 创建一个 *Ticker (而 time.Tick 是一个辅助函数，它执行相同的操作，但直接返回 *Ticker.C，股票代码的接收 channel ，而不是 *Ticker，因此您可以用它来编写代码)在运行时具有类似的 Hook :股票代码是一个包含一个 runtimeTimer 和一个用于发出滴答信号的 channel 的结构。

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

然后，真正的等待/调度发生在从 channel 接收时，这本质上与 select 语句相同，除非 otherChan 在刻度之前发送了一些内容，所以让我们看看阻塞接收时会发生什么。

<- 陈

channel 是通过 hchan 结构在 src/runtime/chan.go 中实现的(现在在 Go 中!)。 channel 操作有配套的函数，接收是通过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) {
  // ...
}

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

所以...

在所有情况下，goroutine 最终都会被停放(这并不令人震惊 - 它无法取得进展，因此它必须将其线程留给不同的 goroutine(如果有可用的)。浏览一下代码似乎表明该 channel 比直接的 time.Sleep 具有更多的开销。然而，它允许更强大的模式，例如示例中的最后一个:goroutine 可以被另一个 channel 唤醒，以先到者为准。

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

channel 中没有轮询，当在 channel 上进行发送时，接收被解锁，在 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 源代码的一次有趣的深入探讨，非常有趣的问题!希望我至少回答了一部分!