Go中的并发模式：Guarded Suspension模式详解与实现

描述
Guarded Suspension（被守护的挂起）模式是一种并发设计模式，用于解决多线程/协程环境下，当某个条件不满足时，线程/协程需要暂时挂起（等待），直到条件满足后再继续执行的场景。其核心思想是：在访问共享资源前，先检查“保护条件”（guard condition），如果条件不满足，则让当前执行体进入等待状态；当其他执行体修改了共享资源使条件满足时，再唤醒等待的执行体。这个模式是生产者-消费者、工作池等模式的基础构建块，在Go中通常结合通道（channel）、互斥锁（sync.Mutex）和条件变量（sync.Cond）来实现。

知识点拆解

1. 保护条件：一个布尔表达式，用于决定是否可以对共享资源进行操作。
2. 挂起与唤醒机制：当条件不满足时，当前协程需要被安全地挂起，避免忙等待（busy-waiting）；当条件可能满足时，需要通知等待的协程。
3. 线程/协程安全：对共享资源和条件变量的操作必须是原子的，防止竞态条件。
4. 适用场景：任务队列非空时才能取任务、缓冲区未满时才能放入数据、连接池中有空闲连接时才能获取连接等。

解题过程（实现步骤）

步骤1：理解基本结构
Guarded Suspension模式包含三个核心部分：

• 共享资源：如一个任务队列、一个缓冲区，通常需要互斥锁保护。
• 保护条件：基于共享资源的状态（如“队列非空”）。
• 协调机制：用于挂起和唤醒协程，Go中可用sync.Cond（基于条件变量）或带缓冲的通道（channel）。

步骤2：使用sync.Mutex和sync.Cond实现
这是最经典的实现方式，适合复杂条件或多个条件变量。

package main

import (
	"fmt"
	"sync"
	"time"
)

// GuardedQueue 一个被守护的队列
type GuardedQueue struct {
	mu    sync.Mutex
	cond  *sync.Cond
	queue []int
}

func NewGuardedQueue() *GuardedQueue {
	q := &GuardedQueue{}
	q.cond = sync.NewCond(&q.mu) // 条件变量需要关联一个互斥锁
	return q
}

// Put 放入元素，如果队列已满（这里假设无界，所以总是成功），则唤醒等待的协程
func (q *GuardedQueue) Put(item int) {
	q.mu.Lock()
	defer q.mu.Unlock()
	
	q.queue = append(q.queue, item)
	fmt.Printf("Put: %d, queue: %v\n", item, q.queue)
	q.cond.Signal() // 唤醒一个等待的协程（任意一个）
	// q.cond.Broadcast() // 如果需要唤醒所有等待的协程，则用Broadcast
}

// Get 获取元素，如果队列为空则挂起等待
func (q *GuardedQueue) Get() int {
	q.mu.Lock()
	defer q.mu.Unlock()
	
	// 必须用循环检查条件，防止虚假唤醒（spurious wakeup）
	for len(q.queue) == 0 {
		fmt.Println("Queue is empty, waiting...")
		q.cond.Wait() // 1. 释放锁；2. 挂起当前协程；3. 被唤醒后重新获取锁
	}
	
	item := q.queue[0]
	q.queue = q.queue[1:]
	fmt.Printf("Get: %d, queue: %v\n", item, q.queue)
	return item
}

func main() {
	q := NewGuardedQueue()
	var wg sync.WaitGroup
	
	// 消费者协程（先启动，会等待）
	wg.Add(1)
	go func() {
		defer wg.Done()
		item := q.Get() // 队列为空，会挂起
		fmt.Printf("Consumed: %d\n", item)
	}()
	
	time.Sleep(2 * time.Second) // 模拟生产延迟
	
	// 生产者协程
	wg.Add(1)
	go func() {
		defer wg.Done()
		q.Put(42) // 放入元素，唤醒消费者
	}()
	
	wg.Wait()
}

关键点解释：

• cond.Wait()必须在持有锁的情况下调用，它内部会释放锁并挂起协程，被唤醒后会自动重新获取锁。
• 条件检查必须用for循环而不是if，因为可能有“虚假唤醒”（操作系统或运行时导致的意外唤醒）。
• Signal()只唤醒一个等待的协程，Broadcast()唤醒所有等待的协程。

步骤3：使用通道（Channel）实现
Go的通道天生具有“挂起-唤醒”语义，更简洁，适合单一条件。

package main

import (
	"fmt"
	"time"
)

// GuardedChannel 使用带缓冲的通道实现
type GuardedChannel struct {
	queue chan int
}

func NewGuardedChannel(capacity int) *GuardedChannel {
	return &GuardedChannel{
		queue: make(chan int, capacity),
	}
}

func (gc *GuardedChannel) Put(item int) {
	gc.queue <- item // 如果通道已满，会阻塞直到有空间
	fmt.Printf("Put: %d\n", item)
}

func (gc *GuardedChannel) Get() int {
	item := <-gc.queue // 如果通道为空，会阻塞直到有元素
	fmt.Printf("Get: %d\n", item)
	return item
}

func main() {
	gc := NewGuardedChannel(3) // 缓冲区大小为3
	
	go func() {
		for i := 1; i <= 5; i++ {
			gc.Put(i)
			time.Sleep(500 * time.Millisecond)
		}
	}()
	
	time.Sleep(2 * time.Second) // 让生产者先放一些数据
	
	for i := 1; i <= 5; i++ {
		gc.Get()
	}
}

通道的优势：代码更简洁，无需显式锁和条件变量；缺点是不适合复杂条件（如多条件组合）。

步骤4：模式变体与注意事项

1. 超时控制：在sync.Cond中，Wait不支持超时，需自己实现（如用time.After和通道组合）；通道可用select实现超时。
2. 多个条件变量：例如队列“非空”和“未满”两个条件，可定义两个sync.Cond，分别用不同的锁保护（但通常共享同一把锁以提高性能）。
3. 避免死锁：确保每个Wait都有对应的唤醒（Signal/Broadcast），且逻辑顺序正确。

总结
Guarded Suspension模式是协调并发执行体的基础工具。在Go中：

• 简单场景优先用通道，利用其阻塞特性。
• 复杂条件或多个条件时用sync.Cond，注意锁的范围和循环检查条件。
• 关键点是“条件检查-挂起-唤醒”的原子性，以及正确处理虚假唤醒。