Go语言中利用双通道实现并发关键代码段的交替执行-Golang-PHP中文网

Go语言中利用双通道实现并发关键代码段的交替执行

DDD

发布： 2025-10-29 17:40:16

原创

344人浏览过

Go语言中利用双通道实现并发关键代码段的交替执行

本文探讨了在go语言并发编程中，如何确保不同goroutine中的关键代码段严格交替执行的问题。通过引入一种基于双通道（dual channels）的令牌传递机制，每个goroutine监听一个通道以获取执行权限，并在完成关键操作后将令牌传递给下一个goroutine。这种模式有效解决了并发环境下的顺序控制难题，并提供了灵活且可扩展的解决方案，适用于需要精确同步执行顺序的场景。

在Go语言的并发模型中，goroutine是轻量级的执行单元，它们通常以非确定性的顺序并行运行。然而，在某些特定场景下，我们可能需要对特定代码段的执行顺序进行严格控制，例如，要求两个或多个goroutine中的“关键代码段”（Critical Section）必须严格交替执行：CS1完成后才能执行CS2，CS2完成后才能执行CS1，如此循环往复。直接启动多个goroutine并不能保证这种顺序，因为调度器会根据自身策略进行调度。

双通道令牌传递模式

为了实现关键代码段的严格交替执行，我们可以采用一种基于“双通道”的令牌传递模式。这种模式的核心思想是：将执行权限抽象为一个“令牌”（token），每个参与交替执行的goroutine都拥有一个专属的“接收通道”来等待令牌，以及一个“发送通道”来在完成任务后将令牌传递给下一个goroutine。通过这种方式，令牌的流动路径就定义了关键代码段的执行顺序。

模式原理

令牌持有与传递： 一个布尔类型的缓冲通道（大小为1）可以作为令牌。当通道中存在值时，表示令牌可用；当值被取出后，通道为空，令牌被“持有”。
等待与执行： 每个goroutine在进入其关键代码段之前，会尝试从其接收通道中读取一个值（<-do）。这个操作是阻塞的，直到令牌可用。一旦读取成功，goroutine就获得了执行关键代码段的权限。
完成与移交： 关键代码段执行完毕后，goroutine会将一个值写入下一个goroutine的接收通道（next <- true）。这相当于将令牌传递给下一个goroutine，使其获得执行权限。
初始化： 为了启动交替执行，需要预先向第一个goroutine的接收通道中发送一个初始令牌。

示例代码

以下Go语言代码演示了如何使用双通道实现两个goroutine中关键代码段的交替执行：

云雀语言模型

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

查看详情

package main

import (
    "fmt"
    "time"
)

// f1 包含关键代码段1的goroutine
func f1(do chan bool, next chan bool) {
    for i := 0; i < 5; i++ { // 循环执行5次以展示交替
        fmt.Println("f1: 等待令牌...")
        <-do // 阻塞，等待从do通道接收令牌
        fmt.Println("f1: 进入关键代码段1 (CS1)")
        // ... 关键代码段1 (CS1) 的具体逻辑 ...
        time.Sleep(100 * time.Millisecond) // 模拟关键代码段执行时间
        fmt.Println("f1: 退出关键代码段1 (CS1)")
        next <- true // 将令牌传递给下一个goroutine (f2)
        fmt.Println("f1: 令牌已发送给f2")
    }
    // 在循环结束后关闭通道，通知另一个goroutine可以停止
    close(next) 
}

// f2 包含关键代码段2的goroutine
func f2(do chan bool, next chan bool) {
    for { // 无限循环，直到do通道被关闭
        fmt.Println("f2: 等待令牌...")
        _, ok := <-do // 阻塞，等待从do通道接收令牌，并检查通道是否关闭
        if !ok {
            fmt.Println("f2: 接收通道已关闭，f2退出。")
            break // 通道关闭，退出循环
        }
        fmt.Println("f2: 进入关键代码段2 (CS2)")
        // ... 关键代码段2 (CS2) 的具体逻辑 ...
        time.Sleep(100 * time.Millisecond) // 模拟关键代码段执行时间
        fmt.Println("f2: 退出关键代码段2 (CS2)")
        next <- true // 将令牌传递给下一个goroutine (f1)
        fmt.Println("f2: 令牌已发送给f1")
    }
}

func main() {
    // 创建两个缓冲通道，容量为1，用于传递令牌
    cf1 := make(chan bool, 1) // f1的接收通道，f2的发送通道
    cf2 := make(chan bool, 1) // f2的接收通道，f1的发送通道

    // 初始令牌：将一个令牌发送到cf1，让f1首先开始执行
    cf1 <- true 
    fmt.Println("main: 初始令牌已发送给f1")

    // 启动两个goroutine，并传入它们各自的接收和发送通道
    go f1(cf1, cf2)
    go f2(cf2, cf1)

    // 为了防止main goroutine过早退出，导致子goroutine无法完成执行，
    // 可以使用select {} 或 sync.WaitGroup 等待。
    // 这里使用一个简单的阻塞方式，等待一段时间或通过通道信号来确保观察到交替执行。
    time.Sleep(2 * time.Second) // 观察一段时间的交替执行
    fmt.Println("main: 程序结束。")
}

登录后复制

代码解析

f1 和 f2 函数：
- 每个函数都接收两个 chan bool 类型的参数：do 和 next。do 是当前goroutine用来接收令牌的通道，next 是当前goroutine用来将令牌发送给下一个goroutine的通道。
- <-do 操作会阻塞当前goroutine，直到从 do 通道接收到一个值。这确保了只有在获得令牌后，关键代码段才能执行。
- next <- true 操作会将一个布尔值发送到 next 通道，从而将令牌传递给下一个等待的goroutine。
- 在 f1 中，我们添加了一个循环来演示多次交替。在 f2 中，我们使用 for {} 循环，并通过 !ok 检查通道是否关闭来安全退出，以应对 f1 循环结束后关闭通道的情况。
main 函数：
- cf1 := make(chan bool, 1) 和 cf2 := make(chan bool, 1)：创建了两个容量为1的缓冲通道。缓冲通道在这里至关重要，它允许在接收方还未准备好接收时，发送方可以发送一个值而不会立即阻塞（只要缓冲区未满）。在这里，容量为1意味着它能存储一个令牌。
- cf1 <- true：这是启动交替执行的关键一步。它将第一个令牌发送到 cf1 通道，使得 f1 goroutine可以首先获得令牌并开始执行。
- go f1(cf1, cf2) 和 go f2(cf2, cf1)：启动两个goroutine。注意通道的传递方式，f1 的 do 是 cf1，next 是 cf2；而 f2 的 do 是 cf2，next 是 cf1。这形成了令牌在 cf1 -> f1 -> cf2 -> f2 -> cf1 之间的循环传递。
- time.Sleep(2 * time.Second)：在实际应用中，main goroutine通常需要通过 sync.WaitGroup、select {} 或其他机制来等待所有子goroutine完成，以避免程序过早退出。这里仅为演示效果而使用简单的延时。

优点与适用场景

严格的交替执行： 这种模式保证了关键代码段的严格顺序执行，不会出现并发冲突或乱序。
可扩展性： 很容易扩展到N个goroutine的交替执行。例如，如果有 f1, f2, f3 三个函数需要交替，只需创建 cf1, cf2, cf3 三个通道，并按 f1(cf1, cf2), f2(cf2, cf3), f3(cf3, cf1) 的方式连接即可。
解耦性： 每个goroutine只关心自己的 do 和 next 通道，不需要了解其他goroutine的内部实现细节。
优雅简洁： 相较于复杂的锁机制或条件变量，通道提供了一种更Go-idiomatic的方式来处理并发同步。

注意事项

通道容量： 使用容量为1的缓冲通道是实现令牌传递的关键。如果使用无缓冲通道，发送操作将立即阻塞直到有接收方准备好，这可能导致死锁或更复杂的逻辑。
死锁风险： 如果令牌传递逻辑出现问题，例如某个goroutine忘记传递令牌，或者通道连接错误，可能会导致死锁，即所有goroutine都在等待令牌而无人发送。
主goroutine的等待： 在实际应用中，main goroutine必须有适当的机制来等待所有子goroutine完成其任务，否则程序可能会在子goroutine执行完毕前退出。常用的方法是使用 sync.WaitGroup。

总结

通过双通道的令牌传递模式，Go语言提供了一种强大而优雅的方式来精确控制并发程序中关键代码段的执行顺序。这种模式不仅保证了严格的交替执行，还具备良好的可扩展性和代码可读性，是处理特定同步需求时的一种高效解决方案。理解并掌握这种模式，将有助于开发者更好地驾驭Go语言的并发特性，构建健壮且高效的并发应用程序。

立即学习“go语言免费学习笔记（深入）”；

以上就是Go语言中利用双通道实现并发关键代码段的交替执行的详细内容，更多请关注php中文网其它相关文章！