Go / 系统课时

实现 Fan-out 与 Fan-in

实现 Fan-out 与 Fan-in

当一批彼此独立的任务需要并行处理时,Fan-out 负责把任务交给多个 worker,Fan-in 再把结果收回到一个消费点。本课用一个可运行的 worker pool,把并行执行、结果汇聚、首个错误传播和取消收敛到同一条退出路径。

学习目标

  • 能用共享任务通道实现受控的 Fan-out,并用结果通道完成 Fan-in。
  • 能在任一 worker 失败时传播首个错误,并取消剩余任务。
  • 能正确安排任务通道、结果通道和错误通道的关闭责任,避免 goroutine 泄漏。

先看结构与关闭责任

最常见的服务级结构是“一处生产、多处执行、一处汇聚”:生产者只负责投递任务,固定数量的 worker 竞争读取同一个任务通道,所有 worker 把结果发送到同一个结果通道。这样既能利用并行度,又不会为每个任务无上限地创建 goroutine。

Fan-out 与 Fan-in 的任务分发、结果汇聚和错误取消路径

关键点不是“开很多 goroutine”,而是谁拥有输出通道,谁负责关闭它。jobs 由生产者关闭;results 必须等所有 worker 都退出后再关闭;接收方只读取,不关闭别人的输入通道。

用一个完整示例串起分发、执行与汇聚

下面的示例固定 3 个 worker。run 内部完成 Fan-out/Fan-in,并用 sync.Once 保证只传播第一个错误。即使某个任务失败,生产者和其他 worker 也会通过同一个 Context 收到取消信号并退出。

go
package main

import (
	"context"
	"fmt"
	"sort"
	"sync"
)

type job struct {
	id    int
	value int
}

type result struct {
	id     int
	square int
}

func worker(
	ctx context.Context,
	jobs <-chan job,
	results chan<- result,
	reportErr func(error),
	wg *sync.WaitGroup,
) {
	defer wg.Done()

	for {
		select {
		case <-ctx.Done():
			return
		case j, ok := <-jobs:
			if !ok {
				return
			}

			// 用一个可预期的业务校验模拟 worker 失败。
			if j.value < 0 {
				reportErr(fmt.Errorf("job %d: negative value %d", j.id, j.value))
				return
			}

			r := result{id: j.id, square: j.value * j.value}
			select {
			case results <- r:
			case <-ctx.Done():
				return
			}
		}
	}
}

func run(values []int, workerCount int) ([]result, error) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	jobs := make(chan job)
	results := make(chan result)
	errCh := make(chan error, 1)

	var wg sync.WaitGroup
	var once sync.Once

	// 首个错误负责触发全局取消,后续错误不再覆盖它。
	reportErr := func(err error) {
		once.Do(func() {
			errCh <- err
			cancel()
		})
	}

	wg.Add(workerCount)
	for i := 0; i < workerCount; i++ {
		go worker(ctx, jobs, results, reportErr, &wg)
	}

	go func() {
		defer close(jobs)
		for id, value := range values {
			select {
			case jobs <- job{id: id, value: value}:
			case <-ctx.Done():
				return
			}
		}
	}()

	// 只有确认全部 worker 已退出后,才能关闭汇聚通道。
	go func() {
		wg.Wait()
		close(results)
		close(errCh)
	}()

	gathered := make([]result, 0, len(values))
	for r := range results {
		gathered = append(gathered, r)
	}

	if err, ok := <-errCh; ok {
		return nil, err
	}

	// 并发完成顺序不稳定,按任务 id 排序后再形成稳定输出。
	sort.Slice(gathered, func(i, j int) bool {
		return gathered[i].id < gathered[j].id
	})
	return gathered, nil
}

func main() {
	okResults, err := run([]int{2, 3, 4, 5}, 3)
	if err != nil {
		panic(err)
	}
	for _, r := range okResults {
		fmt.Printf("job %d => %d\n", r.id, r.square)
	}

	_, err = run([]int{2, -1, 4}, 3)
	fmt.Println("second run:", err)
}

预期输出:

text
job 0 => 4
job 1 => 9
job 2 => 16
job 3 => 25
second run: job 1: negative value -1

worker 的真实完成顺序可能不同,但示例在汇聚后按任务编号排序,因此控制台输出稳定。第二次运行不会返回部分结果,而是返回首个错误,让调用方明确选择“整批失败”还是改造成“允许部分成功”。

错误传播要和取消绑定

只把错误写进 errCh 还不够。如果生产者继续发送,而失败后的 worker 已经退出,发送方可能永远阻塞;如果其他 worker 继续做无意义工作,又会浪费 CPU 和下游配额。因此错误路径需要同时做两件事:记录首个错误,并调用 cancel()。

每个可能阻塞的发送和接收都应能观察 ctx.Done()。这样取消可以穿透生产者、worker 和结果发送点,整个并发结构才有共同的退出条件。错误通道使用容量 1,是为了让首错上报本身不会因为主协程暂时未读取而卡住失败 worker。

控制并行度而不是追求 goroutine 数量

Fan-out 的 worker 数应由 CPU、下游并发额度和单任务特征决定。CPU 密集型任务通常接近可用核心数;I/O 密集型任务可以更高,但仍应有明确上限。把“每个请求都再启动无限 goroutine”当作并行策略,最终通常会把延迟问题转化为调度、内存或下游拥塞问题。

Fan-in 的价值则是把并发完成顺序重新收敛成一个可管理的消费边界。只要坚持固定并行度、首错取消、单点关闭和可取消的阻塞操作,这个模式就能稳定地扩展到批量 RPC、文件处理和并行查询等服务场景。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现 Fan-out 与 Fan-in

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通