背景：

       在开发项目之前之所以使用go语言是因为Go天生支持高并发，只需要go func（）就可以实现一个用户态的协程，占用的资源非常小仅仅2k左右（并且支持动态扩容），而正常采用java，c++等语言启用的线程一般都是内核态的占用的内存资源一般在4m左右，而假设我们的服务器CPU内存为4G，那么很明显才用的内核态线程的并发总数量也就是1024个，相反查看一下Go语言的协程则可以达到4*1024*1024/2=200w.这么一看就明白了为什么Go语言天生支持高并发；这样一看我们发现根本不需要考虑协程池的使用，直接go func一直启用就好了，但是万事难料，我们举一个很不好的例子那就是大量的协程创建销毁需要消耗cpu性能，为了减少这些不必要的性能损失，同时可以支持高并发我们必须想办法再去减少一些不必要的cup性能损耗。 例如Java为了减少这种不必要的线程创建销毁的性能损失，官方包提供相关的线程池方案一共有四种：

  1. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
  2. newFixedThreadPool  创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  3. newScheduledThreadPool 创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行。 
  4. newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

那么go语言也有相关的协程池方案，而且使用最广泛同时性能最稳定的就是ants。    

 使用实例：

var tunnel = make(chan string, 1) // 取决于函数业务的参数类型

func Test66(t *testing.T) {
	go IncomingZombie()

	chairPool, _ := ants.NewPoolWithFunc(3, ExecuteZombie) // 声明有几把电椅
	defer chairPool.Release()

	for {
		select {
		case a := <-tunnel:
			go chairPool.Invoke(a) //将参数传输给执行函数
			fmt.Println("当前执行的协程数： ", chairPool.Running())
		}
	}
}

// 处决僵尸
func ExecuteZombie(i interface{}) {
	fmt.Printf("正在处决僵尸 %s 号，还有5秒钟....\n", i.(string))
	time.Sleep(1 * time.Second)
	fmt.Printf(":) %s 玩完了，下一个\n-----------------\n", i.(string))
}

// 僵尸不断进来
func IncomingZombie() {
	for i := 0; i < 4; i++ {
		tunnel <- strconv.Itoa(i)
	}
}

执行效果：

=== RUN   Test66
当前执行的协程数：  0
当前执行的协程数：  0
当前执行的协程数：  0
正在处决僵尸 1 号，还有5秒钟....
正在处决僵尸 2 号，还有5秒钟....
正在处决僵尸 0 号，还有5秒钟....
当前执行的协程数：  3
:) 2 玩完了，下一个
-----------------
:) 0 玩完了，下一个
-----------------
正在处决僵尸 3 号，还有5秒钟....
:) 1 玩完了，下一个
-----------------
:) 3 玩完了，下一个
-----------------

二.  Tcp连接池的创建使用