Go语言中通过goroutine和channel实现Worker Pool，核心是固定数量的worker从任务队列中取任务执行。1. 基本结构包括任务、任务channel、worker协程和sync.WaitGroup等待机制。2. 示例代码启动3个worker处理5个job，使用有缓存channel作为队列，close后for-range自动退出。3. 增强版增加结果channel，worker处理完任务将结果发送回，主协程收集结果，需用goroutine在wg完成后关闭结果channel。4. 适用场景为高并发任务如网络请求、文件处理，优势是控制并发数防资源耗尽，减少调度开销，提升效率。关键点：合理设置worker数、及时关闭channel、正确使用WaitGroup。
Go语言中实现Worker Pool（工作池）模式，主要是利用goroutine和channel来控制并发任务的数量，避免无限制创建协程导致资源耗尽。核心思路是启动固定数量的工作协程（Workers），通过任务队列分发任务，从而高效处理大量并发任务。
1. 基本结构设计
Worker Pool通常包含以下几个部分：
- 任务（Task）：需要执行的函数或操作，通常封装为一个函数类型。
- 任务队列（Job Queue）：使用channel接收待处理的任务。
- Worker协程：从任务队列中读取任务并执行。
- 等待机制：确保所有任务执行完毕，常配合sync.WaitGroup使用。
2. 简单实现示例
下面是一个典型的Worker Pool实现：
立即学习“go语言免费学习笔记（深入）”；
package main
<p>import (
"fmt"
"sync"
"time"
)</p><p>// 任务类型：这里以整数ID表示任务
type Job struct {
ID int
}</p><p>// 执行任务的函数
func worker(id int, jobs <-chan Job, wg *sync.WaitGroup) {
defer wg.Done()
for job := range jobs {
fmt.Printf("Worker %d started job %d\n", id, job.ID)
time.Sleep(time.Second) // 模拟处理时间
fmt.Printf("Worker %d finished job %d\n", id, job.ID)
}
}</p><p>func main() {
const numWorkers = 3
const numJobs = 5</p><pre class='brush:php;toolbar:false;'>jobs := make(chan Job, numJobs)
var wg sync.WaitGroup
// 启动worker
for i := 1; i <= numWorkers; i++ {
wg.Add(1)
go worker(i, jobs, &wg)
}
// 发送任务
for j := 1; j <= numJobs; j++ {
jobs <- Job{ID: j}
}
close(jobs)
// 等待所有worker完成
wg.Wait()}
这段代码会输出类似：
Golang Uber Dig
下载
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
Worker 2 started job 2
Worker 3 started job 3
Worker 1 finished job 1
Worker 1 started job 4
...
3. 支持结果返回的增强版
如果任务需要返回结果，可以增加一个结果channel：
立即学习“go语言免费学习笔记（深入）”；
type Result struct {
JobID int
Success bool
}
<p>func workerWithResult(id int, jobs <-chan Job, results chan<- Result, wg *sync.WaitGroup) {
defer wg.Done()
for job := range jobs {
// 模拟处理逻辑
success := job.ID%2 == 0 // 偶数任务成功
results <- Result{JobID: job.ID, Success: success}
}
}</p><p>func main() {
const numWorkers = 3
const numJobs = 6</p><pre class='brush:php;toolbar:false;'>jobs := make(chan Job, numJobs)
results := make(chan Result, numJobs)
var wg sync.WaitGroup
// 启动带结果返回的worker
for i := 1; i <= numWorkers; i++ {
wg.Add(1)
go workerWithResult(i, jobs, results, &wg)
}
// 提交任务
for j := 1; j <= numJobs; j++ {
jobs <- Job{ID: j}
}
close(jobs)
// 等待完成并关闭结果channel
go func() {
wg.Wait()
close(results)
}()
// 收集结果
for result := range results {
fmt.Printf("Job %d completed: %v\n", result.JobID, result.Success)
}}
4. 使用场景与优势
Worker Pool适合以下情况：
- 批量处理大量任务（如文件处理、网络请求）。
- 需要限制并发数量防止系统过载。
- 任务处理时间较长，但提交频率高。
相比每次任务都起一个goroutine，Worker Pool能有效减少调度开销，提升资源利用率。
基本上就这些。Go的channel和goroutine让Worker Pool实现变得简洁而高效。关键是合理设置worker数量，并根据是否需要结果选择合适的数据流结构。不复杂但容易忽略的是及时关闭channel和正确使用WaitGroup。
