Go语言中关键代码段的严格交替执行模式

秋敏同学_2628

发布时间：2025-10-29 12:14:36

197人浏览过

来源于php中文网

原创

Go语言中关键代码段的严格交替执行模式

本文探讨了在go语言中如何利用双通道（dual channels）模式，确保并发执行的goroutine中的特定关键代码段能够严格交替运行。通过为每个goroutine分配一个接收通道和一个发送通道，并初始化一个“令牌”，可以实现精确的顺序控制，确保关键代码段按照cs1, cs2, cs1, cs2…的模式执行，且该模式易于扩展。

理解并发中的顺序挑战

在Go语言中，goroutine的轻量级特性使得并发编程变得简单高效。然而，当需要对共享资源或特定操作施加严格的执行顺序时，尤其是在不同的goroutine中，传统的互斥锁（sync.Mutex）虽然能保证原子性，但无法强制执行严格的交替顺序。例如，如果存在两个goroutine f1 和 f2，它们各自包含一个关键代码段 CS1 和 CS2，我们可能需要确保 CS1 必须在 CS2 之后执行，而 CS2 又必须在 CS1 之后执行，形成一个严格的 CS1, CS2, CS1, CS2... 循环。

双通道模式：令牌传递机制

为了解决这种严格的交替执行需求，可以采用一种“令牌传递”的双通道模式。这种模式的核心思想是：每个参与交替执行的goroutine都拥有两个通道，一个用于接收执行权限的“令牌”，另一个用于在完成自身关键代码段后将“令牌”传递给下一个goroutine。

工作原理

令牌初始化： 在程序启动时，首先向第一个需要执行的goroutine的接收通道发送一个“令牌”（通常是一个布尔值或空结构体），赋予它初始的执行权限。
等待令牌： 每个goroutine在进入其关键代码段之前，会尝试从其接收通道中读取数据。如果通道为空（即没有令牌），goroutine将阻塞，直到接收到令牌。
执行关键代码段： 一旦goroutine成功接收到令牌，它便获得了执行其关键代码段的权限，并开始执行。
传递令牌： 关键代码段执行完毕后，goroutine会将令牌发送到下一个goroutine的接收通道中，从而将执行权限传递出去。
循环往复： 这种接收-执行-发送的循环机制确保了各个goroutine的关键代码段严格按照预设的顺序交替执行。

示例代码

下面是一个使用双通道模式实现 CS1 和 CS2 严格交替执行的Go语言示例：

Go语言（Golang）1.26.0

Go语言（Golang）1.26.0版本官方下载，版本号 1.26.0，适合旧项目维护、兼容性测试和指定版本开发环境搭建。

下载

package main

import (
    "fmt"
    "time"
)

// f1 函数包含关键代码段 CS1
func f1(do chan bool, next chan bool) {
    for i := 0; i < 3; i++ { // 循环执行3次以演示交替
        // ... some code before CS1
        fmt.Println("f1: 等待令牌...")
        <-do // 等待接收令牌，获取执行CS1的权限
        fmt.Println("f1: 接收到令牌，执行 CS1")
        // critical section 1 (CS1)
        // 模拟关键代码段的执行
        time.Sleep(100 * time.Millisecond)
        fmt.Println("f1: CS1 执行完毕")
        // end critical section 1

        next <- true // 将令牌传递给下一个goroutine (f2)
        fmt.Println("f1: 令牌已传递给 f2")
        // ... more code after CS1
    }
}

// f2 函数包含关键代码段 CS2
func f2(do chan bool, next chan bool) {
    for i := 0; i < 3; i++ { // 循环执行3次以演示交替
        // ... some code before CS2
        fmt.Println("f2: 等待令牌...")
        <-do // 等待接收令牌，获取执行CS2的权限
        fmt.Println("f2: 接收到令牌，执行 CS2")
        // critical section 2 (CS2)
        // 模拟关键代码段的执行
        time.Sleep(100 * time.Millisecond)
        fmt.Println("f2: CS2 执行完毕")
        // end critical section 2

        next <- true // 将令牌传递给下一个goroutine (f1)
        fmt.Println("f2: 令牌已传递给 f1")
        // ... more code after CS2
    }
}

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

    // 初始化：将第一个令牌发送给 cf1，让 f1 首先启动
    cf1 <- true

    // 启动 goroutine
    go f1(cf1, cf2) // f1 监听 cf1，完成后发送给 cf2
    go f2(cf2, cf1) // f2 监听 cf2，完成后发送给 cf1

    // 为了防止 main goroutine 提前退出，导致子 goroutine 未完成
    // 这里使用 select{} 阻塞 main goroutine。
    // 在实际应用中，通常会使用 sync.WaitGroup 来等待所有 goroutine 完成。
    select {}
}

代码解析

通道创建与缓冲： cf1 := make(chan bool, 1) 和 cf2 := make(chan bool, 1) 创建了两个容量为1的缓冲通道。容量为1至关重要，它确保了令牌在任何时候只有一个，实现了严格的令牌传递。
初始令牌： cf1
在 f1 和 f2 函数内部，
next 关键代码段执行完毕后，next
main goroutine 阻塞： select {} 用于阻塞 main goroutine，以确保 f1 和 f2 有足够的时间执行。否则，main goroutine 可能会在子 goroutine 完成前退出，导致程序提前终止。在生产环境中，更推荐使用 sync.WaitGroup 来精确控制等待所有并发任务完成。

优点与扩展性

严格交替： 这种模式能够确保关键代码段的严格交替执行，不会出现乱序。
清晰的控制流： 令牌的传递路径清晰，易于理解和调试。
易于扩展： 该模式可以轻松扩展到三个或更多 goroutine 的交替执行。例如，如果有 f1, f2, f3 需要交替，可以创建 cf1, cf2, cf3 三个通道，并让 f1 传递给 cf2，f2 传递给 cf3，f3 传递给 cf1，形成一个环形传递链。

注意事项

死锁风险： 如果令牌传递逻辑出现错误（例如，某个 goroutine 没有传递令牌，或者传递到了错误的通道），可能会导致死锁，即所有 goroutine 都处于等待令牌的状态。
性能考量： 对于极高频率的关键代码段执行，通道操作可能引入一定的开销。但对于需要严格顺序控制的场景，这种开销通常是可接受的。
替代方案： 这种模式主要用于严格的、循环的交替执行。对于更复杂的同步需求，例如一次性屏障、等待所有任务完成等，sync.WaitGroup、sync.Once、sync.Cond 或其他更高级的通道模式可能更合适。