并发编程包之 Errgroup

开发 项目管理
Task 是需要处理单个工作单元;Worker 是一个简单的 worker 函数,用于执行任务;而 Pool 用于创建、管理 workers。

[[415494]]

本文转载自微信公众号「Golang来啦」,作者Seekload 。转载本文请联系Golang来啦公众号。

四哥水平有限,如果有翻译或理解错误的点,烦请帮忙指出,感谢!

这是系列文章的第二篇,第一篇文章点击这里查看。

原文如下:

基于 goroutine 和 channel 的并发特性,使得 Go 成为了强大的并发语言。上一篇文章,我们讨论了如何构建 workerPool 来提高程序的并发性能,换句话说,避免耗尽系统资源。但那只是一个简单的示例,演示我们应该如何实现。

基于对上一篇文章的学习,在这篇文章里面,我们将构建一个健壮的解决方案,以便在任何其他应用程序里面可以使用该方案。网络上有其他复杂架构的解决方案,比如使用调度器等等。实际上,我们并不需要这些复杂的设计,仅仅使用一个共享 channel 就可以解决问题。我们一起来看下,该如何构建呢?

代码结构

我们创建了一个通用的 workerPool 包,根据业务所需的并发性使用 worker 来处理任务。一起来看下目录结构:

  1. workerpool 
  2. ├── pool.go 
  3. ├── task.go 
  4. └── worker.go 

workerpool 目录在项目的根目录下。Task 是需要处理单个工作单元;Worker 是一个简单的 worker 函数,用于执行任务;而 Pool 用于创建、管理 workers。

实现

先看下 Task 代码:

  1. // workerpool/task.go 
  2.  
  3. package workerpool 
  4.  
  5. import ( 
  6.  "fmt" 
  7.  
  8. type Task struct { 
  9.  Err  error 
  10.  Data interface{} 
  11.  f    func(interface{}) error 
  12.  
  13. func NewTask(f func(interface{}) error, data interface{}) *Task { 
  14.  return &Task{f: f, Data: data} 
  15.  
  16. func process(workerID int, task *Task) { 
  17.  fmt.Printf("Worker %d processes task %v\n", workerID, task.Data) 
  18.  task.Err = task.f(task.Data) 

Task 是一个简单的结构体,保存处理任务所需要的一切数据。创建 task 时,传递了 Data 和待执行函数 f,process() 函数会处理任务。处理任务时,将 Data 作为参数传递给函数 f,并将执行结果保存在 Task.Err 里。

我们来看下 Worker 是如何处理任务的:

  1. // workerpool/worker.go 
  2.  
  3. package workerpool 
  4.  
  5. import ( 
  6.  "fmt" 
  7.  "sync" 
  8.  
  9. // Worker handles all the work 
  10. type Worker struct { 
  11.  ID       int 
  12.  taskChan chan *Task 
  13.  
  14. // NewWorker returns new instance of worker 
  15. func NewWorker(channel chan *Task, ID int) *Worker { 
  16.  return &Worker{ 
  17.   ID:       ID, 
  18.   taskChan: channel, 
  19.  } 
  20.  
  21. // Start starts the worker 
  22. func (wr *Worker) Start(wg *sync.WaitGroup) { 
  23.  fmt.Printf("Starting worker %d\n", wr.ID) 
  24.  
  25.  wg.Add(1) 
  26.  go func() { 
  27.   defer wg.Done() 
  28.   for task := range wr.taskChan { 
  29.    process(wr.ID, task) 
  30.   } 
  31.  }() 

我们创建了一个小巧的 Worker 结构体,包含 worker ID 和 一个保存待处理任务的 channel。在 Start() 方法里,使用 for range 从 taskChan 读取任务并处理。可以想象的到,多个 worker 可以并发地执行任务。

workerPool

我们通过实现 Task 和 Worker 来处理任务,但是好像还缺点什么东西,谁负责生成这些 worker 并将任务发送给它们?答案是:Worker Pool。

  1. // workerpoo/pool.go 
  2.  
  3. package workerpool 
  4.  
  5. import ( 
  6.  "fmt" 
  7.  "sync" 
  8.  "time" 
  9.  
  10. // Pool is the worker pool 
  11. type Pool struct { 
  12.  Tasks   []*Task 
  13.  
  14.  concurrency   int 
  15.  collector     chan *Task 
  16.  wg            sync.WaitGroup 
  17.  
  18. // NewPool initializes a new pool with the given tasks and 
  19. // at the given concurrency. 
  20. func NewPool(tasks []*Task, concurrency int) *Pool { 
  21.  return &Pool{ 
  22.   Tasks:       tasks, 
  23.   concurrency: concurrency, 
  24.   collector:   make(chan *Task, 1000), 
  25.  } 
  26.  
  27. // Run runs all work within the pool and blocks until it's 
  28. // finished. 
  29. func (p *Pool) Run() { 
  30.  for i := 1; i <= p.concurrency; i++ { 
  31.   worker := NewWorker(p.collector, i) 
  32.   worker.Start(&p.wg) 
  33.  } 
  34.  
  35.  for i := range p.Tasks { 
  36.   p.collector <- p.Tasks[i] 
  37.  } 
  38.  close(p.collector) 
  39.  
  40.  p.wg.Wait() 

上面的代码,pool 保存了所有待处理的任务,并且生成与 concurrency 数量一致的 goroutine,用于并发地处理任务。workers 之间共享缓存 channel -- collector。

所以,当我们把这个工作池跑起来时,可以生成满足所需数量的 worker,workers 之间共享 collector channel。接着,使用 for range 读取 tasks,并将读取到的 task 写入 collector 里。我们使用 sync.WaitGroup 实现协程之间的同步。现在我们有了一个很好的解决方案,一起来测试下。

  1. // main.go 
  2.  
  3. package main 
  4.  
  5. import ( 
  6.  "fmt" 
  7.  "time" 
  8.  
  9.  "github.com/Joker666/goworkerpool/workerpool" 
  10.  
  11. func main() { 
  12.  var allTask []*workerpool.Task 
  13.  for i := 1; i <= 100; i++ { 
  14.   task := workerpool.NewTask(func(data interface{}) error { 
  15.    taskID := data.(int
  16.    time.Sleep(100 * time.Millisecond) 
  17.    fmt.Printf("Task %d processed\n", taskID) 
  18.    return nil 
  19.   }, i) 
  20.   allTask = append(allTask, task) 
  21.  } 
  22.  
  23.  pool := workerpool.NewPool(allTask, 5) 
  24.  pool.Run() 

上面的代码,创建了 100 个任务并且使用 5 个并发处理这些任务。

输出如下:

  1. Worker 3 processes task 98 
  2. Task 92 processed 
  3. Worker 2 processes task 99 
  4. Task 98 processed 
  5. Worker 5 processes task 100 
  6. Task 99 processed 
  7. Task 100 processed 
  8. Took ===============> 2.0056295s 

处理 100 个任务花费了 2s,如何我们将并发数提高到 10,我们会看到处理完所有任务只需要大约 1s。

我们通过实现 workerPool 构建了一个健壮的解决方案,具有并发性、错误处理、数据处理等功能。这是个通用的包,不耦合具体的实现。我们可以使用它来解决一些大问题。

进一步扩展:后台处理任务

实际上,我们还可以进一步扩展上面的解决方案,以便 worker 可以在后台等待我们投递新的任务并处理。为此,代码需要做一些修改,Task 结构体保持不变,但是需要小改下 Worker,看下面代码:

  1. // workerpool/worker.go 
  2.  
  3. // Worker handles all the work 
  4. type Worker struct { 
  5.  ID       int 
  6.  taskChan chan *Task 
  7.  quit     chan bool 
  8.  
  9. // NewWorker returns new instance of worker 
  10. func NewWorker(channel chan *Task, ID int) *Worker { 
  11.  return &Worker{ 
  12.   ID:       ID, 
  13.   taskChan: channel, 
  14.   quit:     make(chan bool), 
  15.  } 
  16.  
  17. .... 
  18.  
  19. // StartBackground starts the worker in background waiting 
  20. func (wr *Worker) StartBackground() { 
  21.  fmt.Printf("Starting worker %d\n", wr.ID) 
  22.  
  23.  for { 
  24.   select { 
  25.   case task := <-wr.taskChan: 
  26.    process(wr.ID, task) 
  27.   case <-wr.quit: 
  28.    return 
  29.   } 
  30.  } 
  31.  
  32. // Stop quits the worker 
  33. func (wr *Worker) Stop() { 
  34.  fmt.Printf("Closing worker %d\n", wr.ID) 
  35.  go func() { 
  36.   wr.quit <- true 
  37.  }() 

Worker 结构体新加 quit channel,并且新加了两个方法。StartBackgorund() 在 for 循环里使用 select-case 从 taskChan 队列读取任务并处理,如果从 quit 读取到结束信号就立即返回。Stop() 方法负责往 quit 写入结束信号。

添加完这两个新的方法之后,我们来修改下 Pool:

  1. // workerpool/pool.go 
  2.  
  3. type Pool struct { 
  4.  Tasks   []*Task 
  5.  Workers []*Worker 
  6.  
  7.  concurrency   int 
  8.  collector     chan *Task 
  9.  runBackground chan bool 
  10.  wg            sync.WaitGroup 
  11.  
  12. // AddTask adds a task to the pool 
  13. func (p *Pool) AddTask(task *Task) { 
  14.  p.collector <- task 
  15.  
  16. // RunBackground runs the pool in background 
  17. func (p *Pool) RunBackground() { 
  18.  go func() { 
  19.   for { 
  20.    fmt.Print("⌛ Waiting for tasks to come in ...\n"
  21.    time.Sleep(10 * time.Second
  22.   } 
  23.  }() 
  24.  
  25.  for i := 1; i <= p.concurrency; i++ { 
  26.   worker := NewWorker(p.collector, i) 
  27.   p.Workers = append(p.Workers, worker) 
  28.   go worker.StartBackground() 
  29.  } 
  30.  
  31.  for i := range p.Tasks { 
  32.   p.collector <- p.Tasks[i] 
  33.  } 
  34.  
  35.  p.runBackground = make(chan bool) 
  36.  <-p.runBackground 
  37.  
  38. // Stop stops background workers 
  39. func (p *Pool) Stop() { 
  40.  for i := range p.Workers { 
  41.   p.Workers[i].Stop() 
  42.  } 
  43.  p.runBackground <- true 

Pool 结构体添加了两个成员:Workers 和 runBackground,Workers 保存所有的 worker,runBackground 用于维持 pool 存活状态。

添加了三个新的方法,AddTask() 方法用于往 collector 添加任务;RunBackground() 方法衍生出一个无限运行的 goroutine,以便 pool 维持存活状态,因为 runBackground 信道是空,读取空的 channel 会阻塞,所以 pool 能维持运行状态。接着,在协程里面启动 worker;Stop() 方法用于停止 worker,并且给 runBackground 发送停止信号以便结束 RunBackground() 方法。

我们来看下具体是如何工作的。

如果是在现实的业务场景中,pool 将会与 HTTP 服务器一块运行并消耗任务。我们通过 for 无限循环模拟这种这种场景,如果满足某一条件,pool 将会停止。

  1. // main.go 
  2.  
  3. ... 
  4.  
  5. pool := workerpool.NewPool(allTask, 5) 
  6. go func() { 
  7.  for { 
  8.   taskID := rand.Intn(100) + 20 
  9.  
  10.   if taskID%7 == 0 { 
  11.    pool.Stop() 
  12.   } 
  13.  
  14.   time.Sleep(time.Duration(rand.Intn(5)) * time.Second
  15.   task := workerpool.NewTask(func(data interface{}) error { 
  16.    taskID := data.(int
  17.    time.Sleep(100 * time.Millisecond) 
  18.    fmt.Printf("Task %d processed\n", taskID) 
  19.    return nil 
  20.   }, taskID) 
  21.   pool.AddTask(task) 
  22.  } 
  23. }() 
  24. pool.RunBackground() 

当执行上面的代码时,我们就会看到有随机的 task 被投递到后台运行的 workers,其中某一个 worker 会读取到任务并完成处理。当满足某一条件时,程序便会停止退出。

总结

基于上一篇文章的初步解决方案,这篇文章讨论了通过 workPool 构建一个强大的解决方案。同时,我们进一步扩展了该方案,实现后台运行 pool 并处理投递的任务。

点击【阅读原文】直达代码仓库[1]。

参考资料

[1]代码仓库: https://github.com/Joker666/goworkerpool

via:https://hackernoon.com/concurrency-in-golang-and-workerpool-part-2-l3w31q7

作者:Hasan

 

责任编辑:武晓燕 来源: Golang来啦
相关推荐

2021-02-26 13:08:27

Java高并发AQS

2018-09-12 15:38:42

Javaatomic编程

2023-07-03 09:59:00

并发编程并发容器

2021-03-11 00:05:55

Java高并发编程

2010-01-15 09:15:09

Scala Actor并发

2023-10-27 07:47:58

Java语言顺序性

2021-03-18 00:14:29

JavaCyclicBarri高并发

2021-03-04 07:24:24

JavaSemaphore高并发

2017-09-19 14:53:37

Java并发编程并发代码设计

2011-12-12 11:16:02

iOS并发编程

2022-10-17 08:07:13

Go 语言并发编程

2022-07-08 14:14:04

并发编程异步编程

2023-07-06 08:06:47

LockCondition公平锁

2011-12-29 13:31:15

Java

2020-04-15 10:24:17

面试并发编程

2023-02-10 09:40:36

Go语言并发

2010-10-14 10:43:43

编程

2023-11-27 18:07:05

Go并发编程

2020-09-04 10:29:47

Java线程池并发

2021-07-22 09:43:09

Golang语言并发机制
点赞
收藏

51CTO技术栈公众号