Go语言通过Goroutine和调度器实现高效并发，合理利用WaitGroup管理生命周期，结合缓冲channel控制并发数，使用context实现超时与取消，避免资源浪费；针对高频短任务可构建协程池复用资源，提升性能。
Go语言通过轻量级的Goroutine和强大的调度器，天然支持高并发任务处理。要提升性能，关键在于合理利用并发机制、控制资源消耗，并结合实际场景设计调度策略。
使用Goroutine与WaitGroup管理任务生命周期
每个Goroutine开销极小（初始栈约2KB），适合启动大量并发任务。但需确保主程序等待所有任务完成，避免提前退出。
建议做法：
- 用sync.WaitGroup协调多个Goroutine的执行结束
- 将任务封装成函数，通过go关键字启动
- 避免无限制创建Goroutine，防止内存溢出或上下文切换开销过大
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Millisecond * 100) // 模拟工作
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait() // 等待所有任务完成
}
通过缓冲Channel控制并发数
当任务数量巨大时，直接全量并发可能导致系统过载。使用带缓冲的channel作为信号量，可限制同时运行的Goroutine数量。
核心思路：
- 创建容量为N的channel，代表最多N个任务并行
- 每个任务开始前从channel接收信号（占用槽位）
- 任务结束后向channel发送信号（释放槽位）
func limitedConcurrency(tasks []func(), maxConcurrent int) {
sem := make(chan struct{}, maxConcurrent)
var wg sync.WaitGroup
for _, task := range tasks {
wg.Add(1)
sem <- struct{}{} // 占用一个并发槽
go func(t func()) {
defer wg.Done()
defer func() { <-sem }() // 释放槽位
t()
}(task)
}
wg.Wait()}
利用Context进行任务取消与超时控制
长时间运行或阻塞的任务应支持中断。context包提供统一的取消机制，防止资源泄漏。
典型应用：
- 设置整体超时：context.WithTimeout
- 主动取消任务树：context.WithCancel
- 将context传入HTTP请求、数据库操作等可能阻塞的调用中
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) defer cancel()results := make(chan string, 1) go func() { result := slowOperation() // 耗时操作 results <- result }()
select {
case res := <-results: fmt.Println("Success:", res) case <-ctx.Done(): fmt.Println("Timeout or canceled") }
case res := <-results:
fmt.Println("Success:", res)
case <-ctx.Done():
fmt.Println("Timeout or canceled")
}结合协程池复用资源降低开销
对于频繁创建销毁的短任务，可使用协程池减少调度压力。虽然Go原生不提供协程池，但可通过channel+固定worker实现。
简单协程池模型：
- 预先启动固定数量的worker Goroutine
- 任务通过channel分发给空闲worker
- 适合CPU密集型或I/O密集型批量处理
基本上就这些。关键是根据业务类型选择合适的并发模式，避免盲目并发反而拖慢系统。
