协程的好处：

跨平台
跨体系架构
无需线程上下文切换的开销
无需原子操作锁定及同步的开销。

代码实现

package main

import (
	"fmt"
	"time"
)
//定义一个任务类型Task
type Task struct {
	f func()error //一个task中有具体的业务，业务名叫f
}
//创建一个任务,包装成一个任务
func NewTask(arg_f func()error) *Task{
	t:=Task{
		f:arg_f,
	}
	return &t
}
//Task执行业务的方法
func(t *Task)Execute(){
	t.f()//调用任务中已经绑定好的业务方法
}
//定义协程池类型
type Pool struct {
	EntryChannel chan *Task//对外的Task入口
	JobChannel chan *Task //协成池中的最大worker数量
	worker_num int
}
func NewPool(cap int) *Pool{
	//创建一个Pool
	p:=Pool{
	EntryChannel:make(chan *Task),
	JobChannel:make(chan *Task),
	worker_num:cap,
	}
	return &p
}
//创建一个work去工作
func(p *Pool)worker(worker_ID int){
	//永久的jobchannel取任务
	for task:=range p.JobChannel{//去消息列中取任务
		//执行任务
	task.Execute()
	fmt.Println("work ID",worker_ID,"执行完了一个任务")
	}
}

func(p *Pool)run(){
	//根据work_num来创建worker工作
	//从entrychananel去工作
	for i:=0;i<p.worker_num;i++{
		//每个worker都应该是一个goroutioe
		go p.worker(i)
	}
	for task:=range p.EntryChannel{//不断从入口取任务,将取到的发送给Job
		p.JobChannel<-task
	}
}

func main() {
	//创建一些任务
	t := NewTask(func() error {
		fmt.Println(time.Now())
		return nil

	})
	//创建一个Pool池
	p := NewPool(4)
	task_num:=0
	go func() {
		for {
			p.EntryChannel <- t
			task_num+=1
			fmt.Println("当前一共执行了",task_num,"个任务")
		}
	}()
p.run()
}