3. Go 语言并发原语回顾：goroutine、channel、sync.WaitGroup、sync.Mutex、sync.RWMutex、atomic 操作

在构建 CQRS 读写分离架构时，并发控制是核心挑战之一。Go 语言提供了轻量级且高效的并发原语，本章将系统回顾这些原语，并分析它们在领域聚合建模与事件溯源中的典型应用场景。

3.1 并发原语全景图

下表对比了 Go 语言中六种核心并发原语的使用场景、性能特征与典型错误模式：

3.2 goroutine 与 channel：事件驱动的基础设施

goroutine 是 Go 并发模型的核心，其调度由 Go 运行时管理，而非操作系统线程。在 CQRS 架构中，每个命令处理器和事件处理器通常运行在独立的 goroutine 中，形成高效的并发处理流水线。

channel 则提供了 goroutine 之间的类型安全通信机制。在事件溯源场景中，channel 常被用作事件总线的内部实现，实现命令端与事件处理器的解耦。

// 事件总线示例：使用 channel 实现异步事件分发
type EventBus struct {
    subscribers map[string][]chan Event
    mu          sync.RWMutex
}

func (eb *EventBus) Publish(event Event) {
    eb.mu.RLock()
    chs, ok := eb.subscribers[event.Type()]
    eb.mu.RUnlock()
    if !ok {
        return
    }
    for _, ch := range chs {
        // 非阻塞发送，避免慢消费者阻塞生产者
        select {
        case ch <- event:
        default:
            // 记录丢弃事件日志
        }
    }
}

3.3 sync.WaitGroup：协调并行任务

当需要等待多个 goroutine 完成后再执行后续操作时，sync.WaitGroup 是最简洁的选择。在 CQRS 的查询端，常用于并行加载多个聚合的快照数据。

// 并行加载多个聚合快照
func LoadAggregates(ids []string) []Aggregate {
    var wg sync.WaitGroup
    results := make([]Aggregate, len(ids))
    
    for i, id := range ids {
        wg.Add(1)
        go func(idx int, aggID string) {
            defer wg.Done()
            results[idx] = loadFromStore(aggID)
        }(i, id)
    }
    
    wg.Wait()
    return results
}

3.4 sync.Mutex 与 sync.RWMutex：聚合根的保护者

在领域驱动设计中，聚合根是数据一致性的边界。当多个命令并发修改同一个聚合根时，必须使用互斥锁保护状态变更。sync.Mutex 提供独占访问，而 sync.RWMutex 在读多写少的场景下能显著提升吞吐量。

// 聚合根使用 RWMutex 保护状态
type OrderAggregate struct {
    mu     sync.RWMutex
    ID     string
    Status OrderStatus
    Items  []OrderItem
}

func (o *OrderAggregate) ApplyEvent(event OrderEvent) {
    o.mu.Lock()
    defer o.mu.Unlock()
    // 应用事件变更聚合状态
    o.Status = event.NewStatus
}

func (o *OrderAggregate) GetStatus() OrderStatus {
    o.mu.RLock()
    defer o.mu.RUnlock()
    return o.Status
}

3.5 atomic 操作：无锁并发基石

atomic 包提供了底层原子内存操作，适用于计数器、版本号、状态标志等简单数据类型的无锁并发控制。在事件溯源中，事件版本号通常使用 atomic 递增，确保全局唯一且无锁。

// 原子版本号生成器
type VersionGenerator struct {
    counter uint64
}

func (vg *VersionGenerator) Next() uint64 {
    return atomic.AddUint64(&vg.counter, 1)
}

// 原子状态标志
type ServiceState struct {
    running int32 // 0: stopped, 1: running
}

func (s *ServiceState) Start() bool {
    return atomic.CompareAndSwapInt32(&s.running, 0, 1)
}

func (s *ServiceState) Stop() bool {
    return atomic.CompareAndSwapInt32(&s.running, 1, 0)
}

3.6 并发原语协作关系图

下图展示了在 CQRS 架构中，各并发原语如何协同工作，构建从命令接收到事件持久化的完整链路：

3.7 并发原语选择决策树

在实际编码中，可根据以下决策树快速选择最合适的并发原语：

1. 是否需要跨 goroutine 通信？
   • 是 → 使用 channel（事件总线、任务流水线）
   • 否 → 进入下一步
2. 是否需要等待多个 goroutine 完成？
   • 是 → 使用 sync.WaitGroup（并行查询、批量处理）
   • 否 → 进入下一步
3. 保护的数据类型是什么？
   • 基本类型（int、bool、指针）→ 使用 atomic（计数器、状态标志）
   • 复合类型（结构体、切片、map）→ 进入下一步
4. 读写比例如何？
   • 读多写少 → 使用 sync.RWMutex（读模型缓存、配置）
   • 写操作频繁 → 使用 sync.Mutex（聚合根状态变更）