简介

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()
}