Golang中如何玩转调度器？

Golang中如何玩转调度器？ 大家好，

我正在研究如何验证Go应用程序，想知道大家是否了解任何可以操控调度器的方法？我只找到了 runtime.Gosched()，它可以让当前goroutine所在的线程（M）被抢占，并将控制权交还给调度器，以执行队列中一个可运行的goroutine。但是，为了在动态验证中系统性地减少搜索空间，我需要一种方法来指定goroutine的交错执行顺序（例如，在上下文切换后执行哪个goroutine）。

如果有人能就此话题提供任何建议，我将不胜感激。

谢谢。

5 回复

感谢 petrus 回复这个问题。

你说得对，并且得益于 Go 的开源特性，是的，我们可以那样做。我只是在想是否还有其他我不知道的方法！

更多关于Golang中如何玩转调度器？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Go 是一个开源项目。你可以克隆源代码，修改运行时调度器，在自己的机器上构建并运行它们。

从源代码安装 Go

我认为，除非你使用 unsafe 包或者修改 Go 源代码，否则这就是你能获得的全部信息。运行时中特意设置了很少的调优参数，这是为了让 Go 团队能够自由地改变其工作方式。

确实如此。 Dmitry Vyukov（以及其他贡献者）凭借极大的创造力设计并编写了出色的调度器（以及整个运行时系统），使其既高效又安全。我正在阅读源代码，以找出负责从可用（即可“运行”）的G队列中选取G的代码区域。这样我就可以修改调度器算法，改为随机选取goroutine来执行。

在Go中直接控制调度器的交错执行顺序是困难的，因为调度器本身被设计为非确定性的，以提供更好的并发性能。不过，有一些方法可以影响调度行为，虽然它们不能完全指定顺序，但可能对你的验证场景有所帮助。

1. 使用 runtime.Gosched()

正如你提到的，runtime.Gosched() 会主动让出当前goroutine的执行权，允许调度器运行其他goroutine。这可以用于创建特定的交错点，但无法控制接下来运行哪个goroutine。

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        fmt.Println("goroutine 1")
    }()
    go func() {
        runtime.Gosched() // 让出执行权
        fmt.Println("goroutine 2")
    }()
    runtime.Gosched() // 主goroutine让出执行权
    fmt.Println("main goroutine")
}

2. 使用通道（Channel）进行同步

通过通道的阻塞和唤醒机制，你可以更精确地控制goroutine的执行顺序。例如，使用无缓冲通道来强制goroutine等待特定信号：

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan bool)
    ch2 := make(chan bool)

    go func() {
        <-ch1 // 等待信号
        fmt.Println("goroutine A")
        ch2 <- true // 发送信号
    }()

    go func() {
        fmt.Println("goroutine B")
        ch1 <- true // 发送信号
        <-ch2       // 等待信号
    }()

    time.Sleep(time.Second) // 等待goroutine完成
}

3. 使用 sync 包中的原语

sync.Mutex、sync.WaitGroup 或 sync.Cond 可以用来协调goroutine的执行。例如，通过条件变量控制执行顺序：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    cond := sync.NewCond(&mu)
    var turn int

    go func(id int) {
        mu.Lock()
        for turn != id {
            cond.Wait()
        }
        fmt.Printf("goroutine %d\n", id)
        turn = 1 - id
        cond.Broadcast()
        mu.Unlock()
    }(0)

    go func(id int) {
        mu.Lock()
        for turn != id {
            cond.Wait()
        }
        fmt.Printf("goroutine %d\n", id)
        turn = 1 - id
        cond.Broadcast()
        mu.Unlock()
    }(1)

    mu.Lock()
    turn = 0
    cond.Broadcast()
    mu.Unlock()

    // 等待goroutine完成
    time.Sleep(time.Second)
}

4. 设置 GOMAXPROCS

通过 runtime.GOMAXPROCS(1) 可以将程序限制在单个操作系统线程上运行，这可以减少交错的不确定性，但并不能完全控制顺序：

package main

import (
    "fmt"
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(1) // 限制为单线程

    go fmt.Println("goroutine 1")
    go fmt.Println("goroutine 2")
    runtime.Gosched()
    fmt.Println("main goroutine")
}

5. 使用调试器或追踪工具

对于动态验证，你可以考虑使用Go的调试器（如Delve）或执行追踪工具（runtime/trace）来观察和分析调度行为。虽然这不能直接控制调度，但可以帮助你理解交错模式：

package main

import (
    "os"
    "runtime/trace"
)

func main() {
    f, _ := os.Create("trace.out")
    trace.Start(f)
    defer trace.Stop()

    // 你的并发代码
    go func() { /* ... */ }()
    go func() { /* ... */ }()
}

6. 实验性的调度器控制

目前，Go标准库没有提供直接控制调度顺序的API。如果你需要更底层的控制，可能需要修改运行时源码或使用实验性工具（如loov/lensm），但这些方法通常不适用于生产环境。

总结：虽然无法完全指定goroutine的交错顺序，但通过组合使用同步原语、runtime.Gosched()和调试工具，你可以在一定程度上影响调度行为，以满足验证需求。

回到顶部