使用goroutine和channel实现并发批量处理，通过Worker Pool模式控制并发数，避免资源耗尽。定义任务与结果channel，启动固定数量worker消费任务并处理，分批发送任务并收集结果。结合errgroup.WithContext管理错误和取消，利用semaphore限制每批并发，按批次处理大数据集防止内存溢出。根据系统负载合理设置并发度和批次大小，配合context实现超时控制，确保程序健壮高效。
在Golang中实现并发批量处理，核心是利用goroutine和channel控制并发数量，避免资源耗尽的同时提升处理效率。关键不是开启无限协程，而是合理控制并发度，分批处理任务。
使用Worker Pool模式控制并发
通过固定数量的worker从任务channel中消费数据，既能并发执行，又能限制最大并发数。
定义一个任务处理函数，将任务发送到channel，多个worker监听该channel并行处理：
func processBatch(tasks []Task, maxWorkers int) {
jobs := make(chan Task, len(tasks))
results := make(chan Result, len(tasks))
// 启动worker
for w := 0; w < maxWorkers; w++ {
go func() {
for task := range jobs {
result := handleTask(task) // 实际处理逻辑
results <- result
}
}()
}
// 发送任务
for _, task := range tasks {
jobs <- task
}
close(jobs)
// 收集结果
var finalResults []Result
for range tasks {
finalResults = append(finalResults, <-results)
}
close(results)}
立即学习“go语言免费学习笔记（深入）”；
使用ErrGroup简化错误处理
当需要处理可能出错的任务时，errgroup.Group 能自动传播第一个错误并取消其他任务。
结合context实现超时控制和统一取消：
import "golang.org/x/sync/errgroup"func processWithErrGroup(ctx context.Context, tasks []Task, limit int) error { g, ctx := errgroup.WithContext(ctx) sem := make(chan struct{}, limit) // 控制并发
for _, task := range tasks { task := task g.Go(func() error { select { case sem <- struct{}{}: defer func() { <-sem }() case <-ctx.Done(): return ctx.Err() } return handleTaskWithError(task, ctx) }) } return g.Wait()}
立即学习“go语言免费学习笔记（深入）”；
分批次处理大数据集
面对大量数据，可以按批次提交任务，每批内部并发处理，避免内存暴涨。
例如每100条任务为一批，逐批处理：
func batchProcess(tasks []Task, batchSize, concurrency int) {
for i := 0; i < len(tasks); i += batchSize {
end := i + batchSize
if end > len(tasks) {
end = len(tasks)
}
batch := tasks[i:end]
// 处理单个批次
processBatch(batch, concurrency)
}}
立即学习“go语言免费学习笔记（深入）”；
基本上就这些。关键是根据系统负载能力设置合理的并发数和批次大小，避免数据库或API被打满。配合context做超时和取消，用errgroup统一处理错误，结构清晰又健壮。
