深入理解 Go 语言调度器与 runtime.Gosched()

Go Goroutine 与调度器概述

Go 语言通过 Goroutine 实现轻量级并发，它比传统的操作系统线程开销更小。Go 运行时（runtime）包含一个调度器，负责管理和调度这些 Goroutine 在底层操作系统线程上执行。调度器的目标是高效地分配 CPU 时间，确保所有 Goroutine 都有机会运行。

runtime.Gosched() 的作用机制

runtime.Gosched() 函数的作用是让当前 Goroutine 放弃其所占用的处理器，并将其放回运行队列。这意味着调度器会暂停当前 Goroutine 的执行，并尝试调度其他可运行的 Goroutine。这是一种协作式多任务的体现，即 Goroutine 必须主动“让出”控制权。

考虑以下 Go 语言代码示例：

package main

import (
    "fmt"
    "runtime"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        // runtime.Gosched() // 注释掉 Gosched()
        fmt.Println(s)
    }
}

func main() {
    go say("world") // 启动一个 Goroutine
    say("hello")    // 主 Goroutine 执行
}

在 Go 1.5 之前，如果 GOMAXPROCS 环境变量未设置（默认为 1），或者显式设置为 1，上述代码的输出可能会是：

hello
hello
hello
hello
hello

在这种情况下，go say("world") 启动的 Goroutine 几乎没有机会执行。这是因为主 Goroutine 在一个循环中连续打印 "hello"，并没有主动放弃 CPU。由于 Go 运行时被限制在一个操作系统线程上运行（GOMAXPROCS=1），调度器无法在主 Goroutine 忙于计算或 I/O 操作时强制切换上下文。

当我们在 say 函数中重新加入 runtime.Gosched()：

package main

import (
    "fmt"
    "runtime"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        runtime.Gosched() // 显式让出 CPU
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

此时，输出将变为交错的 "hello" 和 "world"：

hello
world
hello
world
hello
world
hello
world
hello

这是因为每次循环迭代时，当前 Goroutine（无论是打印 "hello" 的主 Goroutine 还是打印 "world" 的 Goroutine）都会调用 runtime.Gosched()，主动通知调度器：“我暂时不需要 CPU 了，你可以去执行其他 Goroutine。” 调度器接收到这个信号后，便会在两个 Goroutine 之间进行上下文切换，从而实现了它们的交替执行。

云雀语言模型

云雀是一款由字节跳动研发的语言模型，通过便捷的自然语言交互，能够高效的完成互动对话

54

查看详情

协作式多任务与抢占式多任务

• 协作式多任务 (Cooperative Multitasking)：在这种模式下，任务（如 Goroutine）必须显式地将控制权让给其他任务。如果一个任务长时间不让出控制权，其他任务就无法执行。Go 语言的 Goroutine 在早期版本中，尤其是在 GOMAXPROCS=1 的情况下，很大程度上依赖于这种模式。
• 抢占式多任务 (Preemptive Multitasking)：这是现代操作系统中线程调度的主流方式。调度器可以在任何时候中断一个正在运行的任务，并将 CPU 分配给另一个任务，而无需任务主动配合。任务对这种切换是无感知的。

Go 语言的 Goroutine 虽然在实现上是“绿色线程”的变种，早期偏向协作，但随着版本迭代，其调度器已逐渐向抢占式靠近，以提供更公平的调度和更好的并发性能。

GOMAXPROCS 的影响

GOMAXPROCS 是一个重要的环境变量或运行时函数参数，它决定了 Go 运行时可以使用多少个操作系统线程来执行 Goroutine。

• Go 1.5 之前：GOMAXPROCS 默认值为 1。这意味着即使有多个 Goroutine，它们也只能在一个操作系统线程上轮流执行。在这种情况下，runtime.Gosched() 对于 Goroutine 间的上下文切换至关重要。
• Go 1.5 及之后：GOMAXPROCS 的默认值被设置为机器的 CPU 核心数。这意味着 Go 运行时可以创建多个操作系统线程，并在这些线程上并行执行 Goroutine。

当 GOMAXPROCS 大于 1 时，情况会发生显著变化。我们可以通过 runtime.GOMAXPROCS() 函数在程序中设置它：

package main

import (
    "fmt"
    "runtime"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        // runtime.Gosched() // 当 GOMAXPROCS > 1 时，Gosched() 的影响减小
        fmt.Println(s)
    }
}

func main() {
    runtime.GOMAXPROCS(2) // 设置使用 2 个 OS 线程
    go say("world")
    say("hello")
}

在 GOMAXPROCS(2) 的设置下，即使不调用 runtime.Gosched()，程序输出也可能呈现出交错状态，甚至是不均匀的交错，例如：

hello
hello
world
hello
world
world
hello
world
hello

这是因为当有多个操作系统线程可用时，Go 调度器可以将不同的 Goroutine 分配到不同的 OS 线程上并行执行。在这种多线程环境下，操作系统自身的抢占式调度机制会发挥作用，线程间的切换是透明且不确定的。因此，runtime.Gosched() 的显式让出变得不再是强制性的，其效果也可能不再那么明显。输出的这种不确定性正是并行执行的特征。

现代 Go 调度器的演进

值得注意的是，Go 调度器一直在不断发展。在较新的 Go 版本中，Go 运行时在 Goroutine 执行 I/O 操作或进行系统调用时，也会强制其让出 CPU。这意味着即使在 GOMAXPROCS 未设置或设置为 1 的情况下，只要 Goroutine 涉及到 I/O 或系统调用，调度器也有机会进行上下文切换。这使得 Go 调度器在很多场景下更接近抢占式调度，减少了对 runtime.Gosched() 的依赖。

总结与注意事项

1. runtime.Gosched() 的核心作用：在 Go 1.5 之前，尤其在 GOMAXPROCS=1 的环境下，它强制当前 Goroutine 放弃 CPU，实现 Goroutine 间的协作式多任务。
2. GOMAXPROCS 的影响：它控制 Go 运行时可用的操作系统线程数。Go 1.5 及以后版本默认值为 CPU 核心数，使得 Goroutine 可以并行执行，并减少了对 Gosched() 的依赖。
3. 调度器演进：现代 Go 调度器在 I/O 和系统调用时也能触发 Goroutine 让出，进一步增强了其“抢占式”特性，使得 Gosched() 在许多常见并发场景下不再是必需品。
4. 适用场景：尽管现代 Go 调度器已很智能，但在某些极端或特定的测试场景中，你可能仍然会使用 runtime.Gosched() 来确保 Goroutine 能够获得执行机会，或者模拟特定的调度行为。
5. 避免过度使用：通常情况下，不应过度依赖 runtime.Gosched() 来解决并发问题。Go 调度器通常能很好地管理 Goroutine，过多的显式调用可能会引入不必要的开销或复杂的调度逻辑。

理解 runtime.Gosched() 及其与 GOMAXPROCS 和 Go 调度器演进的关系，有助于开发者更深入地掌握 Go 语言的并发模型，并编写出高效、健壮的并发程序。

以上就是深入理解 Go 语言调度器与 runtime.Gosched()的详细内容，更多请关注php中文网其它相关文章！