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