Goroutine + Channel 基础通信是常见并发模型，通过Goroutine执行任务并用Channel传递数据，避免竞态，适用于异步任务处理、数据流水线和结果收集。
Go语言凭借其轻量级的Goroutine和强大的Channel机制，成为构建高并发程序的热门选择。在实际开发中，掌握常见的并发模式和对应场景的解决方案，能有效提升程序的稳定性与性能。以下是几种典型并发模式及其适用场景的总结。
1. Goroutine + Channel 基础通信
这是最基础也是最常用的并发模型。通过启动Goroutine执行任务，并使用Channel在Goroutine之间传递数据，避免共享内存带来的竞态问题。
适用场景：异步任务处理、数据流水线、结果收集。
示例：
立即学习“go语言免费学习笔记（深入）”；
func worker(in <-chan int, out chan<- int) {
for n := range in {
out <- n * n
}
}
func main() {
in := make(chan int, 10)
out := make(chan int, 10)
go worker(in, out)
go worker(in, out)
in <- 2
in <- 3
close(in)
fmt.Println(<-out, <-out) // 输出 4 9
}
多个Worker从输入Channel读取任务，处理后写入输出Channel，实现简单的并发计算。
2. WaitGroup 等待任务完成
当需要等待多个Goroutine执行完毕时，sync.WaitGroup 是理想选择。它通过计数器控制主协程阻塞，直到所有子任务完成。
适用场景：批量任务并行处理、初始化多个服务。
使用要点：
- 在主协程中调用 Add(n) 设置任务数
- 每个Goroutine执行完调用 Done()
- 主协程调用 Wait() 阻塞等待
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
fmt.Printf("worker %d done\n", id)
}(i)
}
wg.Wait()
fmt.Println("all workers finished")
3. Context 控制协程生命周期
在复杂的调用链中，需要统一的机制来传递取消信号、超时或截止时间。context.Context 正是为此设计。
适用场景：HTTP请求处理、数据库查询超时、级联取消。
eSiteGroup站群管理系统是基于eFramework低代码开发平台构建，是一款高度灵活、可扩展的智能化站群管理解决方案，全面支持SQL Server、SQLite、MySQL、Oracle等主流数据库，适配企业级高并发、轻量级本地化、云端分布式等多种部署场景。通过可视化建模与模块化设计，系统可实现多站点的快速搭建、跨平台协同管理及数据智能分析，满足政府、企业、教育机构等组织对多站点统一管控的
常见用法：
- WithCancel：手动触发取消
- WithTimeout：设置超时时间
- WithDeadline：设定截止时间
- WithValue：传递请求上下文数据（如trace ID）
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) defer cancel()go func() { time.Sleep(200 * time.Millisecond) cancel() // 超时后主动取消 }()
select { case <-time.After(150 * time.Millisecond): fmt.Println("operation timed out") case <-ctx.Done(): fmt.Println("received cancel signal") }
4. 单例模式与 once.Do
确保某个操作只执行一次，比如初始化配置、连接池等。Go标准库提供 sync.Once 来实现线程安全的单次执行。
适用场景：全局资源初始化、懒加载。
var once sync.Once var config *Configfunc GetConfig() *Config { once.Do(func() { config = loadConfig() }) return config }
即使多个Goroutine同时调用 GetConfig，loadConfig 也只会执行一次。
5. 生产者-消费者模型
使用Channel天然支持该模式。生产者向Channel发送任务，消费者Goroutine从Channel接收并处理。
适用场景：消息队列、日志处理、后台任务调度。
关键点：
- 使用带缓冲Channel控制并发压力
- 关闭Channel通知消费者结束
- 配合WaitGroup确保所有消费者退出
jobs := make(chan int, 10) results := make(chan int, 10)// 启动3个消费者 for w := 0; w < 3; w++ { go func() { for job := range jobs { results <- job * 2 } }() }
// 生产者 for j := 0; j < 5; j++ { jobs <- j } close(jobs)
// 收集结果 for i := 0; i < 5; i++ { fmt.Println(<-results) }
6. 限制并发数（信号量模式）
当需要控制最大并发量（如避免过多数据库连接），可以使用带缓冲的Channel模拟信号量。
适用场景：爬虫限流、API调用节流、资源池管理。
sem := make(chan struct{}, 3) // 最多3个并发
for i := 0; i < 10; i++ {
sem <- struct{}{} // 获取令牌
go func(id int) {
defer func() { <-sem }() // 释放令牌
fmt.Printf("worker %d starting\n", id)
time.Sleep(1 * time.Second)
fmt.Printf("worker %d done\n", id)
}(i)
}
通过固定大小的Channel实现并发控制，结构清晰且易于理解。
基本上就这些。Go的并发模型简洁而强大，关键在于根据场景选择合适的组合：Goroutine负责并发执行，Channel用于通信与同步，Context管理生命周期，WaitGroup协调完成，once保证初始化安全。掌握这些模式，能应对大多数并发编程需求。不复杂但容易忽略的是对Channel关闭、资源泄漏和死锁的预防，编写时需格外注意。
