Go语言中并发临界区交替执行的优雅实现：基于双通道模式-Golang-PHP中文网

Go语言中并发临界区交替执行的优雅实现：基于双通道模式

本文探讨go语言中如何确保两个或多个并发goroutine的临界区代码段严格交替执行。通过引入“双通道”模式，每个goroutine拥有一个接收通道和一个发送通道，形成一个信号传递的闭环，有效控制临界区的执行顺序，实现精确的交替调度，并具备良好的扩展性，是处理此类并发同步问题的简洁高效方案。

在并发编程中，我们经常需要协调不同Goroutine的执行顺序，尤其是在涉及共享资源或特定业务逻辑时。有时，我们不仅需要确保临界区互斥执行，更要求它们严格按照特定的顺序交替执行，例如：临界区A执行后必须是临界区B，B执行后又必须是A，如此往复。Go语言提供了强大的并发原语，其中通道（channel）是实现这种精细控制的理想工具。

并发临界区交替执行的需求

假设我们有两个Goroutine f1 和 f2，它们各自包含一个临界区代码段（CS1和CS2）。我们的目标是确保这两个临界区始终交替执行：CS1 -> CS2 -> CS1 -> CS2 ...。传统的互斥锁（sync.Mutex）只能保证临界区不会同时被多个Goroutine访问，但无法强制执行顺序。要实现严格的交替执行，我们需要一种机制来让Goroutine在完成自己的临界区后，明确地“通知”下一个Goroutine开始执行其临界区。

双通道机制：原理与设计

解决这种交替执行问题的核心思想是构建一个“令牌传递”系统，我们称之为“双通道模式”。每个参与交替执行的Goroutine都拥有两个通道：

接收通道 (do channel): 用于接收“执行令牌”，表示轮到该Goroutine执行其临界区了。
发送通道 (next channel): 用于在完成临界区后，将“执行令牌”传递给下一个Goroutine。

通过这种设计，Goroutine在进入临界区前会尝试从其接收通道获取令牌。如果通道为空，它将阻塞，直到有令牌到来。一旦获取令牌并完成临界区，它会将令牌发送到下一个Goroutine的接收通道，从而激活下一个Goroutine。这就像传递一个“接力棒”，确保每次只有一个Goroutine持有接力棒（即执行令牌），并按照预设的顺序传递。

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

代码实现与解析

下面通过一个具体的Go语言示例来展示如何实现双通道模式。

云雀语言模型

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

查看详情

Goroutine函数设计 (f1, f2)

每个Goroutine函数需要接收两个通道参数：一个用于接收令牌（do），另一个用于发送令牌（next）。

package main

import (
    "fmt"
    "time"
)

// f1 包含临界区1，并在完成后将令牌传递给f2
func f1(do chan bool, next chan bool, id int) {
    for i := 0; i < 3; i++ { // 循环执行几次以观察交替效果
        // ... some code before critical section 1
        fmt.Printf("Goroutine %d: Before CS1\n", id)

        <-do // 等待接收令牌，表示轮到f1执行CS1

        // critical section 1 (CS1)
        fmt.Printf("Goroutine %d: Executing CS1 (Iteration %d)\n", id, i+1)
        time.Sleep(100 * time.Millisecond) // 模拟临界区工作
        // end critical section 1

        next <- true // 将令牌发送给下一个Goroutine (f2)
        fmt.Printf("Goroutine %d: After CS1, passed token\n", id)

        // ... more code after critical section 1
    }
}

// f2 包含临界区2，并在完成后将令牌传递给f1
func f2(do chan bool, next chan bool, id int) {
    for i := 0; i < 3; i++ { // 循环执行几次以观察交替效果
        // ... some code before critical section 2
        fmt.Printf("Goroutine %d: Before CS2\n", id)

        <-do // 等待接收令牌，表示轮到f2执行CS2

        // critical section 2 (CS2)
        fmt.Printf("Goroutine %d: Executing CS2 (Iteration %d)\n", id, i+1)
        time.Sleep(100 * time.Millisecond) // 模拟临界区工作
        // end critical section 2

        next <- true // 将令牌发送给下一个Goroutine (f1)
        fmt.Printf("Goroutine %d: After CS2, passed token\n", id)

        // ... more code after critical section 2
    }
}

登录后复制

主函数调度 (main)

在 main 函数中，我们需要创建两个带缓冲的通道，并初始化第一个Goroutine的接收通道，使其能够率先启动。

func main() {
    // 创建两个带缓冲的通道，缓冲大小为1，确保每次只有一个令牌在流通
    cf1 := make(chan bool, 1) // f1的接收通道，f2的发送通道
    cf2 := make(chan bool, 1) // f2的接收通道，f1的发送通道

    // 初始时，将一个令牌放入cf1，让f1能够首先启动其临界区
    cf1 <- true

    // 启动两个Goroutine
    go f1(cf1, cf2, 1) // f1 接收cf1的令牌，完成后将令牌发送到cf2
    go f2(cf2, cf1, 2) // f2 接收cf2的令牌，完成后将令牌发送到cf1

    // 为了防止main Goroutine过早退出，导致子Goroutine无法完成，
    // 我们需要一个机制来等待。这里使用select{}来阻塞main Goroutine，
    // 实际应用中可能使用sync.WaitGroup或特定的退出信号。
    select {}
}

登录后复制

完整示例代码

package main

import (
    "fmt"
    "time"
)

// f1 包含临界区1，并在完成后将令牌传递给f2
func f1(do chan bool, next chan bool, id int) {
    for i := 0; i < 3; i++ { // 循环执行几次以观察交替效果
        fmt.Printf("Goroutine %d: Waiting for token to execute CS1\n", id)
        <-do // 等待接收令牌，表示轮到f1执行CS1

        // critical section 1 (CS1)
        fmt.Printf("Goroutine %d: Executing CS1 (Iteration %d)\n", id, i+1)
        time.Sleep(100 * time.Millisecond) // 模拟临界区工作
        // end critical section 1

        next <- true // 将令牌发送给下一个Goroutine (f2)
        fmt.Printf("Goroutine %d: Finished CS1, passed token to next\n", id)
    }
}

// f2 包含临界区2，并在完成后将令牌传递给f1
func f2(do chan bool, next chan bool, id int) {
    for i := 0; i < 3; i++ { // 循环执行几次以观察交替效果
        fmt.Printf("Goroutine %d: Waiting for token to execute CS2\n", id)
        <-do // 等待接收令牌，表示轮到f2执行CS2

        // critical section 2 (CS2)
        fmt.Printf("Goroutine %d: Executing CS2 (Iteration %d)\n", id, i+1)
        time.Sleep(100 * time.Millisecond) // 模拟临界区工作
        // end critical section 2

        next <- true // 将令牌发送给下一个Goroutine (f1)
        fmt.Printf("Goroutine %d: Finished CS2, passed token to next\n", id)
    }
}

func main() {
    // 创建两个带缓冲的通道，缓冲大小为1，确保每次只有一个令牌在流通
    cf1 := make(chan bool, 1) // f1的接收通道，f2的发送通道
    cf2 := make(chan bool, 1) // f2的接收通道，f1的发送通道

    // 初始时，将一个令牌放入cf1，让f1能够首先启动其临界区
    cf1 <- true

    // 启动两个Goroutine
    go f1(cf1, cf2, 1) // f1 接收cf1的令牌，完成后将令牌发送到cf2
    go f2(cf2, cf1, 2) // f2 接收cf2的令牌，完成后将令牌发送到cf1

    // 为了防止main Goroutine过早退出，导致子Goroutine无法完成，
    // 这里使用select{}来阻塞main Goroutine。
    // 在实际生产环境中，更推荐使用sync.WaitGroup来精确等待所有Goroutine完成。
    // 例如：
    // var wg sync.WaitGroup
    // wg.Add(2) // 假设f1和f2内部有wg.Done()
    // go f1(cf1, cf2, 1, &wg)
    // go f2(cf2, cf1, 2, &wg)
    // wg.Wait()
    select {}
}

登录后复制

运行上述代码，你将看到CS1和CS2的执行日志严格交替出现，证明了双通道模式的有效性。

模式的优势与扩展

严格交替： 该模式确保了临界区按照预设的顺序严格交替执行，不会出现乱序或并发执行的情况。
简洁明了： 通过通道的发送和接收操作，清晰地表达了令牌的传递和Goroutine的等待机制。
高度可扩展： 这种模式不仅限于两个Goroutine。如果你有 f1, f2, f3 需要交替执行，你可以创建 cf1, cf2, cf3 三个通道，让 f1 将令牌传给 f2，f2 传给 f3，f3 再传回 f1，形成一个环形链。

关键考量与最佳实践

通道缓冲大小： 必须使用缓冲大小为1的通道。如果通道是无缓冲的，发送操作将阻塞直到有接收者准备好，这在某些情况下可能导致死锁或逻辑复杂化。缓冲为1确保了令牌的唯一性，即每次只有一个Goroutine持有执行权。
初始令牌： 必须在程序开始时向第一个Goroutine的接收通道发送一个令牌，否则所有Goroutine都将阻塞等待令牌，导致死锁。
主Goroutine的等待： main 函数必须等待所有子Goroutine完成其工作，否则程序可能会在子Goroutine完成前退出。在示例中使用了 select {} 来无限期阻塞 main，但这通常不是生产环境的最佳实践。更推荐使用 sync.WaitGroup 来精确管理Goroutine的生命周期。
错误处理： 在实际应用中，需要考虑Goroutine异常退出或通道关闭的情况，这可能导致令牌传递中断，从而引发死锁。