使用Go Channel实现并发临界区的严格交替执行-Golang-PHP中文网

使用Go Channel实现并发临界区的严格交替执行

花韻仙語

发布： 2025-10-28 14:34:01

原创

396人浏览过

使用Go Channel实现并发临界区的严格交替执行

本文探讨了如何在go语言中，利用双通道（dual channel）机制，确保多个并发协程（goroutines）中的临界区（critical sections）严格按照预设的顺序交替执行。通过为每个协程分配一个接收通道和一个发送通道，实现了一种令牌传递模式，有效解决了并发资源访问的同步问题，并展示了该模式的实现细节及其可扩展性。

在Go语言的并发编程中，我们经常会遇到需要多个协程访问共享资源（即临界区）的情况。通常，我们会使用互斥锁（sync.Mutex）来保证临界区在某一时刻只有一个协程在执行。然而，在某些特定场景下，我们可能需要更精细的控制，例如要求两个或多个临界区严格按照特定的顺序交替执行：CS1 -> CS2 -> CS1 -> CS2，依此类推。本文将介绍一种利用Go语言通道（channel）的强大特性，实现这种严格交替执行模式的有效方法。

问题描述

假设我们有两个并发运行的Go协程 f1 和 f2，它们各自包含一个临界区（CS1和CS2）：

func f1() {
    // ... some code
    // critical section 1 (CS1)
    // ... critical section code
    // end critical section 1
    // ... more code
}

func f2() {
    // ... some code
    // critical section 2 (CS2)
    // ... critical section code
    // end critical section 2
    // ... more code
}

登录后复制

我们的目标是确保 CS1 只能在 CS2 执行之后执行，反之亦然，形成一个严格的 CS1, CS2, CS1, CS2... 的交替序列。

双通道机制：核心思想

为了实现这种严格的交替执行，我们可以采用一种“令牌传递”的模式，其中Go通道充当了传递令牌的媒介。核心思想如下：

每个参与交替的协程都拥有两个通道： 一个用于接收“执行令牌”（do 通道），另一个用于发送“完成令牌”（next 通道）。
接收令牌： 一个协程在进入其临界区之前，会尝试从其 do 通道接收一个令牌。如果通道为空，它将阻塞，直到有令牌可用。
发送令牌： 当一个协程完成其临界区的执行后，它会将一个令牌发送到下一个协程的 do 通道中。
初始化： 在程序启动时，需要向第一个要执行的协程的 do 通道中发送一个初始令牌，以启动整个交替序列。

通过这种机制，令牌在协程之间循环传递，确保了只有持有令牌的协程才能进入其临界区，从而实现了严格的交替执行。

魔乐社区

天翼云和华为联合打造的AI开发者社区，支持AI模型评测训练、全流程开发应用

102

查看详情

实现细节与示例代码

下面是使用双通道机制实现两个协程临界区交替执行的完整Go语言示例代码。为了更好地演示，我们在临界区中加入了打印语句和短暂的延迟，并让协程持续循环执行。

package main

import (
    "fmt"
    "time"
)

// f1 协程负责执行临界区1
func f1(id int, do chan bool, next chan bool) {
    for { // 持续循环以演示交替执行
        <-do // 等待接收令牌，表示轮到f1执行
        fmt.Printf("Goroutine %d: Executing Critical Section 1\n", id)
        // --------------------------------------------------
        // critical section 1 (CS1)
        // 这里放置f1的临界区代码
        time.Sleep(100 * time.Millisecond) // 模拟临界区工作
        // end critical section 1
        // --------------------------------------------------
        next <- true // 完成CS1后，将令牌传递给下一个协程
    }
}

// f2 协程负责执行临界区2
func f2(id int, do chan bool, next chan bool) {
    for { // 持续循环以演示交替执行
        <-do // 等待接收令牌，表示轮到f2执行
        fmt.Printf("Goroutine %d: Executing Critical Section 2\n", id)
        // --------------------------------------------------
        // critical section 2 (CS2)
        // 这里放置f2的临界区代码
        time.Sleep(100 * time.Millisecond) // 模拟临界区工作
        // end critical section 2
        // --------------------------------------------------
        next <- true // 完成CS2后，将令牌传递给下一个协程
    }
}

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

    // 初始令牌：向cf1发送一个令牌，让f1首先开始执行
    cf1 <- true

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

    // 保持主协程运行，否则程序会立即退出，无法观察到子协程的交替执行
    select {} // 阻塞主协程，直到程序被手动终止
}

登录后复制

代码解析

f1 和 f2 函数：
- 这两个函数现在都接受两个 chan bool 类型的参数：do 和 next。
- <-do：这是协程进入临界区前的阻塞点。它会尝试从 do 通道接收一个布尔值。如果通道中没有值，协程就会暂停执行，直到有值被发送过来。
- 临界区代码：一旦接收到令牌，协程就可以安全地执行其临界区代码。
- next <- true：临界区执行完毕后，协程会将一个布尔值发送到 next 通道。这个操作会解除下一个协程的阻塞。
- for {} 循环：为了实现持续的交替执行，我们将整个逻辑包裹在一个无限循环中。
- id 参数：仅用于在打印输出时区分不同的协程。
main 函数：
- cf1 := make(chan bool, 1) 和 cf2 := make(chan bool, 1)：创建了两个带缓冲（大小为1）的布尔型通道。缓冲大小为1至关重要，它确保了令牌在通道中可以被存储一次，实现“一进一出”的传递。
- cf1 <- true：这是启动整个交替序列的关键一步。它向 cf1 通道发送了一个令牌，使得 f1 协程能够首先接收到令牌并开始执行。
- go f1(1, cf1, cf2)：启动 f1 协程，并将 cf1 作为其 do 通道（接收令牌），cf2 作为其 next 通道（发送令牌）。
- go f2(2, cf2, cf1)：启动 f2 协程，并将 cf2 作为其 do 通道，cf1 作为其 next 通道。这样就形成了一个环路：f1 完成后令牌给 f2，f2 完成后令牌给 f1。
- select {}：这个语句会阻塞 main 协程，使其不会立即退出。如果没有它，main 函数会执行完毕并终止程序，导致 f1 和 f2 协程没有足够的时间运行。

注意事项与扩展性

通道缓冲： 使用缓冲大小为1的通道是实现令牌传递模式的关键。如果使用无缓冲通道，发送操作在没有接收者时会立即阻塞，这可能导致死锁或无法启动。缓冲为1允许令牌在发送者和接收者之间短暂地“停留”。
主协程阻塞： 在实际应用中，select {} 只是一个简单的阻塞 main 协程的方法。更健壮的生产级代码可能会使用 sync.WaitGroup 来等待所有协程完成，或者使用一个上下文（context.Context）来管理协程的生命周期。
错误处理： 示例代码未包含错误处理。在真实的临界区代码中，需要考虑可能发生的错误和异常情况，并确保令牌能够正确传递，即使临界区执行失败。
扩展到N个协程： 这种模式可以很容易地扩展到N个协程的交替执行。你只需要创建N个通道，并将它们连接成一个环形链表。例如，f1 将令牌传给 f2，f2 传给 f3，...，fN 传回给 f1。
公平性： 这种基于通道的令牌传递机制天然保证了严格的公平性，因为令牌是按顺序传递的。