2. Go并发模型基础：goroutine与GMP调度模型、channel与select、sync.WaitGroup与errgroup

在支付系统中，高并发是常态。Go语言通过轻量级的goroutine和高效的GMP调度模型，配合channel、select以及sync.WaitGroup、errgroup等同步原语，为构建高性能支付服务提供了坚实基础。本章将深入剖析这些核心机制，帮助你在支付场景中精准驾驭并发。

2.1 goroutine与GMP调度模型

goroutine是Go语言并发编程的基石，其栈空间初始仅几KB，可动态伸缩，创建成本远低于操作系统线程。Go运行时通过GMP模型实现高效的M:N调度，将大量goroutine映射到少量系统线程上执行。

GMP核心组件

GMP调度流程

1. 创建G：通过go func()创建的新G被放入当前P的本地队列或全局队列。
2. M获取G：空闲的M尝试从绑定的P的本地队列获取G；若本地队列为空，则从全局队列或其他P的队列偷取（work stealing）一半的G。
3. 执行G：M执行G中的函数，直到G主动让出（如channel阻塞、系统调用）或时间片用完。
4. 阻塞处理：当G因系统调用阻塞时，M与P解绑，P寻找新的M继续执行；阻塞的M等待系统调用返回后，尝试获取一个空闲的P继续执行。
5. 抢占调度：Go 1.14+引入基于信号的异步抢占，防止长时间运行的G饿死其他G。

2.2 channel与select：支付消息的管道

channel是Go语言中CSP（Communicating Sequential Processes）模型的核心实现，用于goroutine之间的通信与同步。在支付系统中，channel常用于传递支付状态、事件通知和任务分发。

channel类型与特性

select多路复用

select语句允许一个goroutine同时等待多个channel操作，当任意一个channel就绪时执行对应分支。这在支付超时控制、多路事件监听中至关重要。

// 支付超时控制示例
func processPayment(ctx context.Context, paymentCh chan PaymentResult) {
    select {
    case result := <-paymentCh:
        // 支付结果处理
        handlePaymentResult(result)
    case <-ctx.Done():
        // 超时或取消处理
        handleTimeout(ctx.Err())
    case <-time.After(5 * time.Second):
        // 自定义超时逻辑
        log.Warn("payment processing timeout")
    }
}

2.3 sync.WaitGroup与errgroup：并发编排利器

在支付系统中，经常需要等待多个并发任务完成（如同时调用风控、账户、订单服务），或在一个任务失败时快速取消其他任务。sync.WaitGroup和errgroup提供了优雅的并发编排方案。

sync.WaitGroup：等待goroutine完成

sync.WaitGroup通过计数器管理goroutine的生命周期：Add(delta)增加计数器，Done()减少计数器，Wait()阻塞直到计数器归零。

// 支付并发调用示例
func processPaymentConcurrently(ctx context.Context, payment *Payment) error {
    var wg sync.WaitGroup
    errCh := make(chan error, 3) // 缓冲channel避免泄漏

    // 并发调用风控服务
    wg.Add(1)
    go func() {
        defer wg.Done()
        if err := callRiskControl(ctx, payment); err != nil {
            errCh <- err
        }
    }()

    // 并发调用账户服务
    wg.Add(1)
    go func() {
        defer wg.Done()
        if err := callAccountService(ctx, payment); err != nil {
            errCh <- err
        }
    }()

    // 并发调用订单服务
    wg.Add(1)
    go func() {
        defer wg.Done()
        if err := callOrderService(ctx, payment); err != nil {
            errCh <- err
        }
    }()

    wg.Wait()      // 等待所有goroutine完成
    close(errCh)   // 关闭错误channel

    // 收集错误
    var errs []error
    for err := range errCh {
        errs = append(errs, err)
    }
    return errors.Join(errs...)
}

errgroup：带错误传播的并发编排

errgroup是sync.WaitGroupgolang.org/x/sync/errgroup包。它自动管理goroutine生命周期，并在任意一个goroutine返回错误时，通过context取消其他goroutine。

// 使用errgroup实现快速失败
func processPaymentWithErrGroup(ctx context.Context, payment *Payment) error {
    g, ctx := errgroup.WithContext(ctx)

    // 设置并发上限为5
    g.SetLimit(5)

    // 并发调用风控服务
    g.Go(func() error {
        return callRiskControl(ctx, payment)
    })

    // 并发调用账户服务
    g.Go(func() error {
        return callAccountService(ctx, payment)
    })

    // 并发调用订单服务
    g.Go(func() error {
        return callOrderService(ctx, payment)
    })

    // Wait返回第一个非nil错误，并自动取消其他goroutine
    return g.Wait()
}

2.4 支付场景并发模型选择指南