Golang并发模式总结常见场景解决方案-Golang-PHP中文网

Golang并发模式总结常见场景解决方案

P粉602998670

发布： 2025-08-22 12:20:02

原创

193人浏览过

Goroutine + Channel 基础通信是常见并发模型，通过Goroutine执行任务并用Channel传递数据，避免竞态，适用于异步任务处理、数据流水线和结果收集。

golang并发模式总结常见场景解决方案

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
    }
}
<p>func main() {
in := make(chan int, 10)
out := make(chan int, 10)</p><pre class='brush:php;toolbar:false;'>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请求处理、数据库查询超时、级联取消。

常见用法：

WithCancel：手动触发取消
WithTimeout：设置超时时间
WithDeadline：设定截止时间
WithValue：传递请求上下文数据（如trace ID）

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
<p>go func() {
time.Sleep(200 * time.Millisecond)
cancel() // 超时后主动取消
}()</p><p>select {
case <-time.After(150 * time.Millisecond):
fmt.Println("operation timed out")
case <-ctx.Done():
fmt.Println("received cancel signal")
}</p>

登录后复制

4. 单例模式与 once.Do

确保某个操作只执行一次，比如初始化配置、连接池等。Go标准库提供 sync.Once 来实现线程安全的单次执行。

适用场景：全局资源初始化、懒加载。

var once sync.Once
var config *Config
<p>func GetConfig() *Config {
once.Do(func() {
config = loadConfig()
})
return config
}</p>

登录后复制

即使多个Goroutine同时调用 GetConfig，loadConfig 也只会执行一次。

5. 生产者-消费者模型

使用Channel天然支持该模式。生产者向Channel发送任务，消费者Goroutine从Channel接收并处理。

适用场景：消息队列、日志处理、后台任务调度。

关键点：

使用带缓冲Channel控制并发压力
关闭Channel通知消费者结束
配合WaitGroup确保所有消费者退出

jobs := make(chan int, 10)
results := make(chan int, 10)
<p>// 启动3个消费者
for w := 0; w < 3; w++ {
go func() {
for job := range jobs {
results <- job * 2
}
}()
}</p><p>// 生产者
for j := 0; j < 5; j++ {
jobs <- j
}
close(jobs)</p><p>// 收集结果
for i := 0; i < 5; i++ {
fmt.Println(<-results)
}</p>

登录后复制

6. 限制并发数（信号量模式）

当需要控制最大并发量（如避免过多数据库连接），可以使用带缓冲的Channel模拟信号量。

适用场景：爬虫限流、API调用节流、资源池管理。

sem := make(chan struct{}, 3) // 最多3个并发
<p>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)
}</p>

登录后复制

通过固定大小的Channel实现并发控制，结构清晰且易于理解。

基本上就这些。Go的并发模型简洁而强大，关键在于根据场景选择合适的组合：Goroutine负责并发执行，Channel用于通信与同步，Context管理生命周期，WaitGroup协调完成，once保证初始化安全。掌握这些模式，能应对大多数并发编程需求。不复杂但容易忽略的是对Channel关闭、资源泄漏和死锁的预防，编写时需格外注意。

以上就是Golang并发模式总结常见场景解决方案的详细内容，更多请关注php中文网其它相关文章！