手把手教你Golang的协程池设计

本文转载自微信公众号「程序员小饭」，作者饭米粒。转载本文请联系程序员小饭公众号。

成都创新互联公司专注于成都网站建设、做网站、网页设计、网站制作、网站开发。公司秉持“客户至上,用心服务”的宗旨,从客户的利益和观点出发,让客户在网络营销中找到自己的驻足之地。尊重和关怀每一位客户，用严谨的态度对待客户，用专业的服务创造价值，成为客户值得信赖的朋友，为客户解除后顾之忧。

前言

现在很多公司都在陆续的搭建golang的语言栈，大家有没有想过为什么会出现这种情况?一是因为go比较适合做中间件，还有一个原因就是go的并发支持比较好，也就是咱们平时所谓的高并发，并发支持离不开协程，当然协程也不是乱用的，需要管理起来，管理协程的方式就是协程池，所以协程池也并没有那么神秘，今天咱们就来一步一步的揭开协程池的面纱，如果你没有接触过go的协程这块的话也没有关系，我会尽量写的详细。

goroutine(协程)

先来看一个简单的例子

  
 
 
 
    
   
  
  
  
  1. func go_worker(name string) { 
    2.    
  
  
  
  2.    for i := 0; i < 5; i++ { 
    3.    
  
  
  
  3.     fmt.Println("我的名字是", name) 
    4.    
  
  
  
  4.     time.Sleep(1 * time.Second) 
    5.    
  
  
  
  5.    } 
    6.    
  
  
  
  6.    fmt.Println(name, "执行完毕") 
    7.    
  
  
  
  7. } 
    8.    
  
  
  
  8. func main() { 
    9.    
  
  
  
  9.     go_worker("123") 
    10.    
  
  
  
  10.     go_worker("456") 
    11.    
  
  
  
  11.    for i := 0; i < 5; i++ { 
    12.    
  
  
  
  12.     fmt.Println("我是main") 
    13.    
  
  
  
  13.     time.Sleep(1 * time.Second) 
    14.    
  
  
  
  14.    } 
    15.    
  
  
  
  15. } 
    16.

咱们在执行这段代码的时候，当然是按照顺序执行

go_worker("123")->go_worker("456")->我是main执行

输出结果如下

  
 
 
 
    
   
  
  
  
  1. 我的名字是 123 
    2.    
  
  
  
  2. 我的名字是 123 
    3.    
  
  
  
  3. 我的名字是 123 
    4.    
  
  
  
  4. 我的名字是 123 
    5.    
  
  
  
  5. 我的名字是 123 
    6.    
  
  
  
  6. 123 执行完毕 
    7.    
  
  
  
  7. 我的名字是 456 
    8.    
  
  
  
  8. 我的名字是 456 
    9.    
  
  
  
  9. 我的名字是 456 
    10.    
  
  
  
  10. 我的名字是 456 
    11.    
  
  
  
  11. 我的名字是 456 
    12.    
  
  
  
  12. 456 执行完毕 
    13.    
  
  
  
  13. 我是main 
    14.    
  
  
  
  14. 我是main 
    15.    
  
  
  
  15. 我是main 
    16.    
  
  
  
  16. 我是main 
    17.    
  
  
  
  17. 我是main 
    18.

这样的执行是并行的，也就是说必须得等一个任务执行结束，下一个任务才会开始，如果某个任务比较慢的话，整个程序的效率是可想而知的，但是在go语言中，支持协程，所以我们可以把上面的代码改造一下

  
 
 
 
    
   
  
  
  
  1. func go_worker(name string) { 
    2.    
  
  
  
  2.    for i := 0; i < 5; i++ { 
    3.    
  
  
  
  3.     fmt.Println("我的名字是", name) 
    4.    
  
  
  
  4.     time.Sleep(1 * time.Second) 
    5.    
  
  
  
  5.    } 
    6.    
  
  
  
  6.    fmt.Println(name, "执行完毕") 
    7.    
  
  
  
  7. } 
    8.    
  
  
  
  8. func main() { 
    9.    
  
  
  
  9.    go go_worker("123")  //协程 
    10.    
  
  
  
  10.    go go_worker("456")  //协程 
    11.    
  
  
  
  11.    for i := 0; i < 5; i++ { 
    12.    
  
  
  
  12.     fmt.Println("我是main") 
    13.    
  
  
  
  13.     time.Sleep(1 * time.Second) 
    14.    
  
  
  
  14.    } 
    15.    
  
  
  
  15. } 
    16.

我们在不同的go_worker前面加上了一个go，这样所有任务就异步的串行了起来，输出结果如下

  
 
 
 
    
   
  
  
  
  1. 我是main 
    2.    
  
  
  
  2. 我的名字是 456 
    3.    
  
  
  
  3. 我的名字是 123 
    4.    
  
  
  
  4. 我的名字是 123 
    5.    
  
  
  
  5. 我是main 
    6.    
  
  
  
  6. 我的名字是 456 
    7.    
  
  
  
  7. 我是main 
    8.    
  
  
  
  8. 我的名字是 456 
    9.    
  
  
  
  9. 我的名字是 123 
    10.    
  
  
  
  10. 我是main 
    11.    
  
  
  
  11. 我的名字是 456 
    12.    
  
  
  
  12. 我的名字是 123 
    13.    
  
  
  
  13. 我的名字是 456 
    14.    
  
  
  
  14. 我的名字是 123 
    15.    
  
  
  
  15. 我是main 
    16.

大家可以看到这样的话就是各自任务执行各自的事情，互相不影响，效率也得到了很大的提升，这就是goroutine

channel(管道)

有了协程之后就会带来一个新的问题，协程之间是如何通信的?于是就引出了管道这个概念，管道其实很简单，无非就是往里放数据，往外取数据而已

  
 
 
 
    
   
  
  
  
  1. func worker(c chan int) { 
    2.    
  
  
  
  2.    num := <-c  //读取管道中的数据，并输出 
    3.    
  
  
  
  3.    fmt.Println("接收到参数c:", num) 
    4.    
  
  
  
  4. } 
    5.    
  
  
  
  5. func main() { 
    6.    
  
  
  
  6.    //channel的创建,需要执行管道数据的类型，我们这里是int 
    7.    
  
  
  
  7.    c := make(chan int) 
    8.    
  
  
  
  8.    //开辟一个协程 去执行worker函数 
    9.    
  
  
  
  9.    go worker(c) 
    10.    
  
  
  
  10.    c <- 2  //往管道中写入2 
    11.    
  
  
  
  11.    fmt.Println("main") 
    12.    
  
  
  
  12. } 
    13.

我们可以看到上述例子，在main函数中，我们定义了一个管道，为int类型，而且往里面写入了一个2，然后在worker中读取管道c，就能获取到2

协程会引发的问题

既然golang中开启协程这么方便，那么会不会存在什么坑呢?

我们可以看上图，实际业务中，不同的业务都开启不同的goroutine来执行，但是在cpu微观层面上来讲，是串行的一个指令一个指令去执行的，只是执行的非常快而已，如果指令来的太多，cpu的切换也会变多，在切换的过程中就需要消耗性能，所以协程池的主要作用就是管理goroutine，限定goroutine的个数

协程池的实现

  • 首先不同的任务，请求过来，直接往entryChannel中写入，entryChannel再和jobsChannel建立通信
  • 然后我们固定开启三个协程(不一定是三个，只是用三个举例子)，固定的从jobsChannel中读取数据，来进行任务处理。
  • 其实本质上，channel就是一道桥梁，做一个中转的作用，之所以要设计一个jobsChannel和entryChannel，是为了解耦，entryChannel可以完全用做入口，jobsChannel可以做更深入的比如任务优先级，或者加锁，解锁等处理

代码实现

原理清楚了，接下来我们来具体看代码实现

首先我们来处理任务 task，task无非就是业务中的各种任务，需要能实力化，并且执行，代码如下

  
 
 
 
    
   
  
  
  
  1. //定义任务Task类型,每一个任务Task都可以抽象成一个函数 
    2.    
  
  
  
  2. type Task struct{ 
    3.    
  
  
  
  3.    f func() error //一个task中必须包含一个具体的业务 
    4.    
  
  
  
  4. } 
    5.    
  
  
  
  5.  
    6.    
  
  
  
  6.  
    7.    
  
  
  
  7. //通过NewTask来创建一个Task 
    8.    
  
  
  
  8. func NewTask(arg_f func() error) *Task{ 
    9.    
  
  
  
  9.    t := Task{ 
    10.    
  
  
  
  10.     f:arg_f, 
    11.    
  
  
  
  11.    } 
    12.    
  
  
  
  12.    return &t 
    13.    
  
  
  
  13. } 
    14.    
  
  
  
  14.  
    15.    
  
  
  
  15.  
    16.    
  
  
  
  16. //Task也需要一个执行业务的方法 
    17.    
  
  
  
  17. func (t *Task) Execute(){ 
    18.    
  
  
  
  18.    t.f()//调用任务中已经绑定好的业务方法 
    19.    
  
  
  
  19. } 
    20.

接下来我们来定义协程池

  
 
 
 
    
   
  
  
  
  1. //定义池类型 
    2.    
  
  
  
  2. type Pool struct{ 
    3.    
  
  
  
  3.    EntryChannel chan *Task 
    4.    
  
  
  
  4.    WorkerNum int 
    5.    
  
  
  
  5.    JobsChanel chan *Task 
    6.    
  
  
  
  6. } 
    7.    
  
  
  
  7. //创建一个协程池 
    8.    
  
  
  
  8. func NewPool(cap int) *Pool{ 
    9.    
  
  
  
  9.    p := Pool{ 
    10.    
  
  
  
  10.     EntryChannel: make(chan *Task), 
    11.    
  
  
  
  11.     JobsChanel: make(chan *Task), 
    12.    
  
  
  
  12.     WorkerNum: cap, 
    13.    
  
  
  
  13.    } 
    14.    
  
  
  
  14.    return &p 
    15.    
  
  
  
  15. } 
    16.

协程池需要创建worker，然后不断的从JobsChannel内部任务队列中拿任务开始工作

  
 
 
 
    
   
  
  
  
  1. //协程池创建worker并开始工作 
    2.    
  
  
  
  2. func (p *Pool) worker(workerId int){ 
    3.    
  
  
  
  3.     //worker不断的从JobsChannel内部任务队列中拿任务 
    4.    
  
  
  
  4.     for task := range p.JobsChanel{ 
    5.    
  
  
  
  5.      task.Execute() 
    6.    
  
  
  
  6.      fmt.Println("workerId",workerId,"执行任务成功") 
    7.    
  
  
  
  7.     } 
    8.    
  
  
  
  8. } 
    9.    
  
  
  
  9. EntryChannel获取Task任务 
    10.    
  
  
  
  10. func (p *Pool) ReceiveTask(t *Task){ 
    11.    
  
  
  
  11.    p.EntryChannel <- t 
    12.    
  
  
  
  12. } 
    13.    
  
  
  
  13. //让协程池开始工作 
    14.    
  
  
  
  14. func (p *Pool) Run(){ 
    15.    
  
  
  
  15.    //1:首先根据协程池的worker数量限定，开启固定数量的worker 
    16.    
  
  
  
  16.    for i:=0; i   
  
  
  
  17.     go p.worker(i) 
    18.    
  
  
  
  18.    } 
    19.    
  
  
  
  19.    //2:从EntryChannel协程出入口取外部传递过来的任务 
    20.    
  
  
  
  20.    //并将任务送进JobsChannel中 
    21.    
  
  
  
  21.    for task := range p.EntryChannel{ 
    22.    
  
  
  
  22.     p.JobsChanel <- task 
    23.    
  
  
  
  23.    } 
    24.    
  
  
  
  24.    //3:执行完毕需要关闭JobsChannel和EntryChannel 
    25.    
  
  
  
  25.    close(p.JobsChanel) 
    26.    
  
  
  
  26.    close(p.EntryChannel) 
    27.    
  
  
  
  27. } 
    28.

然后我们看在main函数中

  
 
 
 
    
   
  
  
  
  1. //创建一个task 
    2.    
  
  
  
  2.    t:= NewTask(func() error{ 
    3.    
  
  
  
  3.     fmt.Println(time.Now()) 
    4.    
  
  
  
  4.     return nil 
    5.    
  
  
  
  5.    }) 
    6.    
  
  
  
  6.  
    7.    
  
  
  
  7.    //创建一个协程池，最大开启5个协程worker 
    8.    
  
  
  
  8.    p:= NewPool(3) 
    9.    
  
  
  
  9.    //开启一个协程，不断的向Pool输送打印一条时间的task任务 
    10.    
  
  
  
  10.    go func(){ 
    11.    
  
  
  
  11.     for { 
    12.    
  
  
  
  12.      p.ReceiveTask(t)//把任务推向EntryChannel 
    13.    
  
  
  
  13.     } 
    14.    
  
  
  
  14.    }() 
    15.    
  
  
  
  15.    //启动协程池p 
    16.    
  
  
  
  16.    p.Run() 
    17.

基于上述方法，咱们一个简单的协程池设计就完成了，当然在实际生产环境中这样做还是不够的，不过这些方法能手写出来，那对golang是相当熟悉了，

责任编辑：武晓燕
来源： 程序员小饭 协程池 Golang 设计

本文题目：手把手教你Golang的协程池设计
文章网址：http://www.shufengxianlan.com/qtweb/news39/488889.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

营销型网站建设知识

同城分类信息

混凝土密封固化剂　　 　小谭建站　　 　二枢服务器托管　　 　成都模板网站　　 　网站制作公司　　 　雅安服务器托管　　 　app开发　　 　成都展柜设计公司　　 　力比特机械　　 　分类目录网站　　 　成都企业网站建设　　 　绵阳服务器托管　　 　网站推广　　 　旅游网站建设方案　　 　班戈纳美网站　　 　公司宣传册设计　　 　雅安电信机房　　 　网络推广　　 　户外广告设计　　 　乐至网站建设