2. Go 并发基础回顾：goroutine 与 channel、sync.WaitGroup、select 多路复用、并发安全原则

在支付系统中，每一笔交易都可能涉及账户扣减、风控校验、渠道调用、日志记录等多个步骤。如果这些步骤串行执行，在高并发场景下延迟会急剧上升。Go 语言通过 goroutine 和 channel 提供了轻量级的并发原语，配合 sync.WaitGroup 和 select 多路复用机制，能够高效地编排支付流程。本章将系统回顾这些核心概念，并强调在支付场景中必须遵守的并发安全原则。

2.1 goroutine：轻量级并发单元

goroutine 是 Go 运行时管理的轻量级线程，创建成本极低（初始栈仅几 KB），可以轻松启动数十万个 goroutine。在支付系统中，每个请求的处理、每个外部渠道的调用都可以独立为一个 goroutine。

// 支付请求处理：异步调用风控与渠道
func ProcessPayment(ctx context.Context, req *PaymentRequest) {
    riskResult := make(chan RiskResponse, 1)
    channelResult := make(chan ChannelResponse, 1)

    go CallRiskService(ctx, req, riskResult)   // 并发调用风控
    go CallChannelGateway(ctx, req, channelResult) // 并发调用渠道

    // 等待两个结果
    risk := <-riskResult
    ch := <-channelResult
    // 合并结果并返回
}

2.2 channel：goroutine 间的安全通信

channel 是 Go 中 goroutine 之间传递数据的管道，遵循“通过通信共享内存”的设计哲学。在支付系统中，channel 常用于传递异步结果、控制并发数量、实现流水线处理。

// 有缓冲 channel 实现支付结果收集
func CollectPaymentResults(ctx context.Context, tasks []PaymentTask) []Result {
    resultCh := make(chan Result, len(tasks))
    for _, task := range tasks {
        go func(t PaymentTask) {
            select {
            case resultCh <- t.Execute(ctx):
            case <-ctx.Done():
                resultCh <- Result{Err: ctx.Err()}
            }
        }(task)
    }

    results := make([]Result, 0, len(tasks))
    for i := 0; i < len(tasks); i++ {
        results = append(results, <-resultCh)
    }
    return results
}

2.3 sync.WaitGroup：等待 goroutine 完成

当需要等待一组 goroutine 全部执行完毕时，sync.WaitGroup 是最简洁的方案。在支付系统中，常用于等待所有下游依赖（如风控、记账、通知）返回后再聚合结果。

func ParallelPaymentSteps(ctx context.Context, order *Order) error {
    var wg sync.WaitGroup
    errCh := make(chan error, 3) // 缓冲避免泄漏

    wg.Add(3)
    go func() { defer wg.Done(); errCh <- DeductBalance(ctx, order) }()
    go func() { defer wg.Done(); errCh <- CallRiskControl(ctx, order) }()
    go func() { defer wg.Done(); errCh <- NotifyMerchant(ctx, order) }()

    wg.Wait()
    close(errCh)

    for err := range errCh {
        if err != nil {
            return err // 返回第一个错误
        }
    }
    return nil
}

2.4 select 多路复用：同时监听多个 channel

select 语句允许一个 goroutine 同时等待多个 channel 操作，是构建超时控制、优雅退出、多路结果聚合的核心工具。在支付网关中，select 常用于同时监听渠道返回、超时信号和系统关闭信号。

func WaitPaymentResult(ctx context.Context, ch chan PaymentResponse) (PaymentResponse, error) {
    select {
    case resp := <-ch:
        return resp, nil
    case <-time.After(5 * time.Second):
        return PaymentResponse{}, ErrTimeout
    case <-ctx.Done():
        return PaymentResponse{}, ctx.Err()
    }
}

// 非阻塞尝试发送到限流 channel
select {
case limiter <- struct{}{}:
    // 获取到令牌，继续处理
    defer func() { <-limiter }()
    ProcessPayment(ctx, req)
default:
    // 限流，快速失败
    return ErrTooManyRequests
}

2.5 并发安全原则

支付系统对数据一致性要求极高，并发安全是必须遵守的底线。以下是 Go 并发编程中必须遵循的核心原则：

// 安全的余额扣减：使用互斥锁
type Account struct {
    mu      sync.Mutex
    balance int64
}

func (a *Account) Deduct(amount int64) error {
    a.mu.Lock()
    defer a.mu.Unlock()
    if a.balance < amount {
        return ErrInsufficientBalance
    }
    a.balance -= amount
    return nil
}

2.6 并发模型与支付流程编排

下图展示了支付系统中典型的并发编排模型，将 goroutine、channel、select 和 WaitGroup 组合使用，实现高效的支付流水线。

2.7 并发安全原则在支付中的落地

下图总结了支付系统中并发安全原则的层次关系，从最基础的 goroutine 通信到最终的数据一致性保障。