#

## 写在前面

在 Go 里写并发程序，最常见的一个需求是：**同时发起多个任务，然后收集它们的结果。**

但收集的方式不止一种。你是**全部等齐再处理**？还是**谁先回来用谁的**？还是**边回来边处理**？

这三种场景，对应了 Go 并发编程里三种不同的模式。这篇文章带你一次性搞清楚。

---

## 场景设定

假设我们有一个酒店后台系统，需要同时查询三个数据源：

- 房价（`fetchPrice`）
- 房态（`fetchRoomStatus`）
- 客户偏好（`fetchPreference`）

每个查询耗时 1-3 秒不等，我们希望能用并发的方式加速。

```go
type QueryResult struct {
Price string
Room string
Prefer string
Err error
}
```

---

## 模式一：全部等齐再处理（`sync.WaitGroup`）

这是最经典的用法：**等所有任务都完成，再统一返回。**

```go
func queryAll(ctx context.Context, room string) QueryResult {
var wg sync.WaitGroup
var mu sync.Mutex
result := QueryResult{}

wg.Add(3)

go func() {
defer wg.Done()
price, err := fetchPrice(ctx, room)
mu.Lock()
result.Price = price
result.Err = err
mu.Unlock()
}()

go func() {
defer wg.Done()
roomStatus, err := fetchRoomStatus(ctx, room)
mu.Lock()
result.Room = roomStatus
if err != nil {
result.Err = err
}
mu.Unlock()
}()

go func() {
defer wg.Done()
prefer, err := fetchPreference(ctx, room)
mu.Lock()
result.Prefer = prefer
if err != nil {
result.Err = err
}
mu.Unlock()
}()

wg.Wait()
return result
}
```

**特点**：
- 三个任务全部完成后，`wg.Wait()` 才放行
- 总耗时 = 最慢的那个任务
- 适合需要完整数据的场景（如生成报表、页面渲染）

---

## 模式二：谁先完成用谁的（一次 `select`）

如果你只关心最快的那个结果，可以用 `select` 取第一个回来的数据。

```go
func queryAny(ctx context.Context, room string) QueryResult {
ch := make(chan QueryResult, 3)

go func() {
price, err := fetchPrice(ctx, room)
ch <- QueryResult{Price: price, Err: err}
}()
go func() {
roomStatus, err := fetchRoomStatus(ctx, room)
ch <- QueryResult{Room: roomStatus, Err: err}
}()
go func() {
prefer, err := fetchPreference(ctx, room)
ch <- QueryResult{Prefer: prefer, Err: err}
}()

select {
case result := <-ch:
return result
case <-ctx.Done():
return QueryResult{Err: ctx.Err()}
}
}
```

**特点**：
- 只取第一个返回的结果，其余忽略
- 总耗时 = 最快的那个任务
- 适合竞争式查询（如查多个缓存、多个供应商报价）

---

## 模式三：边完成边收集（循环 `select`）

如果你既要**全部结果**，又想**边完成边处理**，可以用 `for` + `select` 循环。

```go
func queryAllWithSelect(ctx context.Context, room string) QueryResult {
ch := make(chan QueryResult, 3)

go func() {
price, err := fetchPrice(ctx, room)
ch <- QueryResult{Price: price, Err: err}
}()
go func() {
roomStatus, err := fetchRoomStatus(ctx, room)
ch <- QueryResult{Room: roomStatus, Err: err}
}()
go func() {
prefer, err := fetchPreference(ctx, room)
ch <- QueryResult{Prefer: prefer, Err: err}
}()

result := QueryResult{}
for i := 0; i < 3; i++ {
select {
case part := <-ch:
if part.Price != "" {
result.Price = part.Price
}
if part.Room != "" {
result.Room = part.Room
}
if part.Prefer != "" {
result.Prefer = part.Prefer
}
if part.Err != nil && result.Err == nil {
result.Err = part.Err
}
case <-ctx.Done():
result.Err = ctx.Err()
return result
}
}
return result
}
```

**特点**：
- 所有结果都能收到
- 可以边收边处理（如实时更新 UI 进度条）
- 总耗时 = 最慢的那个任务，但不会卡死（有超时保护）

---

## 三种模式对比一览

| 模式 | 工具 | 结果完整性 | 总耗时 | 适用场景 |
| :--- | :--- | :--- | :--- | :--- |
| 全部等齐 | `sync.WaitGroup` | ✅ 全部 | 最慢的任务 | 报表、完整页面 |
| 取最快 | 一次 `select` | ❌ 一个 | 最快的任务 | 缓存竞争、降级 |
| 边收边等 | 循环 `select` | ✅ 全部 | 最慢的任务 | 进度展示、实时更新 |

---

## 总结

Go 的并发模型并不复杂，但“收集结果”这个看似简单的需求，其实有几种不同的实现方式。

**选择哪个，取决于你的业务需求：**

- 需要全部数据？👉 用 `WaitGroup`
- 只要最快的那一个？👉 用 `select`
- 全部都要，还要实时反馈？👉 用循环 `select`

这三种模式，你学会了吗？