上一篇文章介绍了封装一个简单的协程池，实现比较简单，缺点是对协程池状态、任务执行等缺乏管理(仅仅把异常任务数统计了下)，本章将难度提高一些，参考go-playground/pool ，封装一个性能更高、特性更丰富些的协程池
  引用源码：https://github.com/go-playground/pool
  文章内容：参考go-playground-pool代码(总共不到1千行代码)，只对协程池的关键特性做了详细说明，代码及变量等名尽量延用源码的命名，减轻阅读压力

使用协程池pool管理工作协程worker，batch用来管理一组批量的工作单元、workunit作为具体的工作单元 对应要执行的具体任务(文中简写为wu)

type limitedPool struct {
	workers uint			//工作协程数
	work    chan *workUnit	//任务队列
	cancel  chan struct{}	//取消信号
	closed  bool			//是否关闭
	m       sync.RWMutex	//操作锁
}

type batch struct {
	pool    Pool			//协程池
	m       sync.Mutex		//操作锁
	units   []WorkUnit		//管理工作单元
	results chan WorkUnit	//结果集
	done    chan struct{}	//结束标识，跨协程阻塞通信模式
	closed  bool			//关闭标识
	wg      *sync.WaitGroup	//工作单元执行的信号量
}

type workUnit struct {
	value      interface{}		//结果
	err        error			        //错误信息
	done       chan struct{}	        //结束标识，跨协程阻塞通信模式
	fn         WorkFunc			//执行的方法
	cancelled  atomic.Value		//已取消
	cancelling atomic.Value		//取消中，
	writing    atomic.Value		//写入状态(在逻辑执行时，才会写入，且当前wu不能再次被cancel)
}

func NewLimited(workers uint) Pool {

	if workers == 0 {
		panic("invalid workers '0'")
	}

	p := &limitedPool{
		workers: workers,
		work: make(chan *workUnit, workers * 2),
		cancel: make(chan struct{}),
		closed: false,
	}

	//开启协程监听任务
	for i := 0; i < int(p.workers); i++ {
		p.newWorker(p.work, p.cancel)
	}

	return p
}

for {
	select {
		case wu = <-work:
			if wu == nil {
				continue
			}

			if wu.cancelled.Load() == nil {
				value, err = wu.fn(wu)
				wu.writing.Store(struct{}{})
				//这一步相当于在writing和cancelled并发时，能把writing给拦截下来(虽然成功了),实际相当于只执行了cancelled
				if wu.cancelled.Load() == nil && wu.cancelling.Load() == nil {
					wu.value, wu.err = value, err

					//关闭wu
					close(wu.done)
				}
			}

		case <-cancel:
			return
		}
	}

func (b *batch) Queue(fn WorkFunc) {
	b.m.Lock()
	if b.closed {
		b.m.Unlock()
		return
	}

	wu := b.pool.Queue(fn)	//任务进pool的任务队列，进行处理

	b.units = append(b.units, wu)
	b.wg.Add(1)
	b.m.Unlock()

	go func(b *batch, wu WorkUnit) {
		wu.Wait()	//阻塞等待wu执行完成
		b.results <- wu	//存入结果集
		b.wg.Done()
	}(b, wu)
}

go func() {		
	p.m.RLock()
	if p.closed {
		w.err = &ErrPoolClosed{s: errClosed}
		if w.cancelled.Load() == nil {
			close(w.done)
		}
		p.m.RUnlock()
		return
	}

	p.work <- w
	p.m.RUnlock()
}()

if wu.cancelled.Load() == nil {
	value, err = wu.fn(wu)
	wu.writing.Store(struct{}{})

	//这一步相当于在writing和cancelled并发时，能把writing给拦截下来(虽然成功了),实际相当于只执行了cancelled
	if wu.cancelled.Load() == nil && wu.cancelling.Load() == nil {
		wu.value, wu.err = value, err
						
		close(wu.done)
		}
}

取消wu代码：

func (wu *workUnit) cancelWithError(err error) {
	wu.cancelling.Store(struct{}{})
	if wu.writing.Load() == nil && wu.cancelled.Load() == nil {
		wu.cancelled.Store(struct{}{})
		wu.err = err
		close(wu.done)
	}
}

func (b *batch) QueueComplete() {
	b.m.Lock()
	b.closed = true	//此后Queue方法不能再添加任务
	close(b.done)	//关闭batch，确保Results方法阻塞执行
	b.m.Unlock()
}

func (b *batch) Results() <-chan WorkUnit {
	go func(b *batch) {
		<-b.done        //线程阻塞 等待b.done被close
		b.m.Lock()
		b.wg.Wait()
		b.m.Unlock()
		close(b.results)
	}(b)

	return b.results
}