Go 中有哪些常见的并发模式？

Question

Go 中有哪些常见的并发模式？

Accepted Answer

Go 的 goroutine 和 channel 支持一套成熟的**并发模式**来解决常见问题——分发工作、扇出/扇入、管道和速率限制。掌握这些习用模式能让你构建正确、高效的并发系统。

## Worker pool — 有界并发

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // a FIXED number of workers
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // each worker pulls jobs until the channel closes
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

**worker pool** 运行固定数量的 goroutine 从共享的 jobs channel 消费——限制并发数量（例如不要打开 10,000 个数据库连接，而是用 10 个 worker）。这是控制资源使用的最重要的模式。

## Fan-out / fan-in

```text
Fan-out: distribute work across MULTIPLE goroutines (parallelize)
Fan-in:  MERGE results from multiple goroutines back into one channel
```

```go
// fan-in: merge several channels into one
func merge(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c { out <- v }   // forward each channel's values to out
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // close out when all sources are drained
    return out
}
```

## Pipeline — 通过 channel 连接的处理阶段

```go
// each stage is a goroutine: receives from an input channel, sends to an output channel
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}
// compose: square(generate(1,2,3)) → a streaming pipeline
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

**管道**通过 channel 链接处理阶段——数据流经各阶段，每个阶段并发地对其进行转换。

## Rate limiting

```go
limiter := time.Tick(200 * time.Millisecond)   // a tick every 200ms
for req := range requests {
    <-limiter                                    // wait for the next tick before proceeding
    go handle(req)                                // → at most 5 requests/second
}
```

## Cancellation with context (cross-cutting)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // stop on cancellation — prevents leaks
}
```

## 为什么这很重要

这些并发模式是构建真实 Go 并发系统的实用工具包，将原始的 goroutine 和 channel 转化为解决常见问题的结构化、正确的方案。

**worker pool** 特别重要——它限制并发数量以保护有限资源（数据库连接、API 速率限制、内存），防止无限制生成 goroutine 导致系统耗尽资源的常见错误。**扇出/扇入**并行化工作并合并结果；**管道**干净地对流式数据转换进行建模；**速率限制**控制吞吐量。

结合**基于 context 的取消**（防止 goroutine 泄漏），这些模式是生产级 Go 服务安全且高效地处理并发的方式。

理解它们——特别是懂得用 worker pool 限制并发而不是无限启动 goroutine——是高级 Go 工程师的标志，也是常见的高阶面试话题，因为幼稚的并发模式（无界 goroutine、泄漏、竞态）是生产环境故障的常见根源。