Go 并发模式：Worker Pool + Context + 限流

package workerpool

import (
	"context"
	"sync"
)

// Task 表示一个可执行任务。
// 约定：任务必须尊重 ctx 的取消信号，避免 goroutine 泄漏。
type Task func(ctx context.Context) error

// RunWorkerPool 以固定并发数执行 tasks。
// - concurrency: 并发 worker 数量（建议按下游容量设置）
// - 返回值：只要有一个任务返回错误，就会触发取消，最终返回该错误
func RunWorkerPool(ctx context.Context, tasks []Task, concurrency int) error {
	if concurrency <= 0 {
		concurrency = 1
	}

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	taskCh := make(chan Task)
	errCh := make(chan error, 1) // 只关心第一个错误

	var wg sync.WaitGroup
	worker := func() {
		defer wg.Done()
		for {
			select {
			case <-ctx.Done():
				return
			case t, ok := <-taskCh:
				if !ok {
					return
				}
				if err := t(ctx); err != nil {
					// 只投递第一个错误，并触发全局取消
					select {
					case errCh <- err:
					default:
					}
					cancel()
					return
				}
			}
		}
	}

	wg.Add(concurrency)
	for i := 0; i < concurrency; i++ {
		go worker()
	}

	// 投递任务（尊重取消）
	go func() {
		defer close(taskCh)
		for _, t := range tasks {
			select {
			case <-ctx.Done():
				return
			case taskCh <- t:
			}
		}
	}()

	wg.Wait()

	select {
	case err := <-errCh:
		return err
	default:
		return nil
	}
}