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 <- 2in <- 3close(in)fmt.Println(<-out, <-out) // 输出 4 9
}
多个Worker从输入Channel读取任务，处理后写入输出Channel，实现简单的并发计算。
2. WaitGroup 等待任务完成
当需要等待多个Goroutine执行完毕时，sync.WaitGroup 是理想选择。它通过计数器控制主协程阻塞，直到所有子任务完成。
适用场景：批量任务并行处理、初始化多个服务。
使用要点：
在主协程中调用 Add(n) 设置任务数每个Goroutine执行完调用 Done()主协程调用 Wait() 阻塞等待
var wg sync.WaitGroupfor i := 0; i < 5; i++ { wg.Add(1) go func(id int) { defer wg.Done() fmt.Printf("worker %d donen", id) }(i)}wg.Wait()fmt.Println("all workers finished")
3. Context 控制协程生命周期
在复杂的调用链中，需要统一的机制来传递取消信号、超时或截止时间。context.Context 正是为此设计。
适用场景：HTTP请求处理、数据库查询超时、级联取消。
常见用法：
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.Oncevar 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 startingn", id)time.Sleep(1 * time.Second)fmt.Printf("worker %d donen", id)}(i)}
通过固定大小的Channel实现并发控制，结构清晰且易于理解。
基本上就这些。Go的并发模型简洁而强大，关键在于根据场景选择合适的组合：Goroutine负责并发执行，Channel用于通信与同步，Context管理生命周期，WaitGroup协调完成，once保证初始化安全。掌握这些模式，能应对大多数并发编程需求。不复杂但容易忽略的是对Channel关闭、资源泄漏和死锁的预防，编写时需格外注意。
以上就是Golang并发模式总结 常见场景解决方案的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1399638.html
微信扫一扫 
支付宝扫一扫 
