golang实现协程池

简介

go语言的协程是十分轻量级的线程,它的销毁创建都在用户空间,因此一般没有必要对协程进行限制,但是某些场景还是需要控制并发数的。

1、可重复利用的协程

//协程池定义
type Pool struct {
    work chan func() //工作协程的chan,无缓冲区(同步)
    sem chan struct{} //控制并发数,带缓冲区
}

Step1:初始化协程池

func NewPool(size int)  *Pool{
    return &Pool{
        work: make(chan func()),
        sem: make(chan struct{}, size),
    }
}

Step2:任务Push接口

func (pool *Pool)NewTask(task func())  {
    select {
    case pool.work <-task:
        fmt.Println("pool.work sends success.")
    case pool.sem  <- struct{}{}:
        go pool.worker(task)
    }
}

1、work chan是一个无缓冲的chan,此处作为生产者往chan内push,如果消费者不存在,不会push成功,也就是select事件不会触发,就会走第二个case。
2、如果两个case都存在事件,那么select会挑选一个分支执行,也即是说,开启的协程是根据当前是否有空闲协程可用,如果有则可能复用,如果没有,则新开协程执行新的任务,协程上限为设置的最大值。

Step3:接收任务,执行任务

func (pool *Pool)worker(task func())  {
    defer func() {
        <- pool.sem //理论上是不会走这个流程
    }()

    //重复利用开启的goroutine 
    for  {
        task()
        //消费者 (如果消费者没准备好,同步的channel就不会发送成功,也就是pool.work <-task 事件不会被触发
        task = <-pool.work
    }
}

优点:可最大化利用协程资源,如果任务频繁,可使用该方式
缺点:
1、开启的协程资源不会被回收,即使没有任务。
2、如果任务中包含阻塞操作,会引发其他任务无法获取资源而一直处于等待

2、每次新建协程执行

与第一种方法一样,使用chan来控制并发数,但是不需要work chan,因为每次都是新建协程,在未达到最大并发之前,直接执行即可。

type Pool2 struct {
    sem chan struct{}
}

func NewPool2(size int)  *Pool2{
    return &Pool2{
        sem: make(chan struct{}, size),
    }
}

func (pool *Pool2)NewTask(task func())  {
    select {
    case pool.sem <- struct{}{}:
        go pool.Worker(task)
    }
}

func (pool *Pool2)Worker(task func())  {
    defer func() {
        fmt.Println("go routing ends.")
        <-pool.sem
    }()

    //此处不能使用go 开启协程,如果开启go,那么defer的内容会被直接执行,也就是达不到限制同时使用的goroutine 数量
    task()
}

推荐阅读更多精彩内容