核心是控制并发数、避免资源耗尽、保证错误可感知和结果可收集；通过带缓冲channel作令牌池（如sem := make(chan struct{}, maxConcurrency)）实现限流，任务前取令牌、结束后归还。
用 Go 实现批量并发任务，核心不是“开一堆 goroutine”，而是控制并发数、避免资源耗尽、保证错误可感知、结果可收集。关键在调度层设计，而非单纯起协程。
控制并发数：用带缓冲的 channel 做信号量
无限制启动 goroutine 容易打爆内存或压垮下游服务。推荐用一个容量为 N 的 channel 作为“令牌池”，每启动一个任务先取一个令牌，任务结束再归还。
- 初始化：
sem := make(chan struct{}, maxConcurrency) - 每个任务前：
sem （阻塞直到有空位） - 任务结束后：
（释放令牌）
这种方式轻量、无锁、语义清晰，比用 sync.WaitGroup + 计数器更直观可控。
统一收集结果与错误：用结构体封装任务输出
不要让每个 goroutine 直接写 map 或 slice —— 竞态风险高。建议每个任务返回一个结构体，包含 index、result、err，通过 channel 汇总：
type TaskResult struct {
Index int
Data interface{}
Err error
}
results := make(chan TaskResult, len(tasks))
主 goroutine 启动后循环接收 len(tasks) 次，按 Index 填入结果切片，自然保持原始顺序，也方便定位哪个任务失败。
支持取消与超时：context.Context 是标配
批量任务常需整体超时或中途取消。把 ctx 传给每个子任务，在 I/O 或重试逻辑中定期检查 ctx.Err()：
- 启动时：
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) - 任务内：
select { case - 主流程监听
ctx.Done()可提前退出等待
注意：cancel 应在所有任务启动后、等待前调用，避免过早中断；也可用 context.WithCancel 配合外部信号触发中断。
简
单封装成可复用函数
单封装成可复用函数把上述逻辑收拢为一个通用函数，调用时只需传入任务列表和并发数：
func RunBatchTasks(ctx context.Context, tasks []func(context.Context) (interface{}, error), maxConcurrent int) ([]interface{}, []error) {
sem := make(chan struct{}, maxConcurrent)
results := make(chan TaskResult, len(tasks))
for i, task := range tasks {
go func(idx int, t func(context.Context) (interface{}, error)) {
sem <- struct{}{}
defer func() { <-sem }()
data, err := t(ctx)
results <- TaskResult{Index: idx, Data: data, Err: err}
}(i, task)
}
out := make([]interface{}, len(tasks))
errs := make([]error, len(tasks))
for range tasks {
r := <-results
out[r.Index] = r.Data
errs[r.Index] = r.Err
}
return out, errs}
调用示例：data, errs := RunBatchTasks(ctx, myTasks, 10) —— 干净、可测、易维护。
基本上就这些。不复杂但容易忽略的是：并发控制要早于任务启动，结果收集要保序可索引，上下文传递要贯穿始终。做到这三点，批量并发就稳了。
