func worker(id int, jobs <-chan int, results chan<- int) {
	for job := range jobs {
		fmt.Printf("worker(%d) start to do job(%d)\n", id, job)
		time.Sleep(time.Second)
		fmt.Printf("worker(%d) finished job(%d)\n", id, job)
		results <- job
	}
}

func main() {
    // 為了使用我們的工作池，我們需要發(fā)送工作和接受工作的結(jié)果，
    // 這里我們定義兩個通道，一個jobs，一個results
	jobs := make(chan int, 100)
	results := make(chan int, 100)
	// 開啟3個goroutine
	for id := 1; id <= 3; id++ {
		go worker(id, jobs, results)
	}
	// 創(chuàng)建5個任務(wù)
	for job := 1; job <= 5; job++ {
		jobs <- job
	}
	close(jobs)
	// 輸出結(jié)果
	for i := 1; i <= 5; i++ {
		<-results
	}
}

1package main

import (
	"fmt"
	"reflect"
	"time"
)

// Job 任務(wù)內(nèi)容
type Job struct {
	ID   int
	Name string
}

// Worker 工作
type Worker struct {
	id         int           // id
	WorkerPool chan chan Job // 工作者池（通道的通道），每個元素都是一個job通道， 公共的job
	JobChannel chan Job      // 工作通道，每個元素是一個job，worker私有的job
	exit       chan bool     // 結(jié)束信號
}

var (
	MaxWorker = 5                 // 最大worker數(shù)量
	JobQueue  = make(chan Job, 5) // 工作通道，模擬需處理的工作
)

// Scheduler 排程中心
type Scheduler struct {
	WorkerPool   chan chan Job // 工作池
	WorkerMaxNum int           // 最大工作者數(shù)
	Workers      []*Worker     // worker隊列
}

// NewScheduler 創(chuàng)建排程中心
func NewScheduler(workerMaxNum int) *Scheduler {
	workerPool := make(chan chan Job, workerMaxNum) // 工作池
	return &Scheduler{WorkerPool: workerPool, WorkerMaxNum: workerMaxNum}
}

// Start 工作池開始
func (s *Scheduler) Start() {
	Workers := make([]*Worker, s.WorkerMaxNum)
	for i := 0; i < s.WorkerMaxNum; i++ {
		worker := NewWorker(s.WorkerPool, i)
		worker.Start()
		Workers[i] = &worker
	}
	s.Workers = Workers
	go s.schedule()
}

// Stop 工作池的關(guān)閉
func (s *Scheduler) Stop() {
	Workers := s.Workers
	for _, w := range Workers {
		w.Stop()
	}
	time.Sleep(time.Second)
	close(s.WorkerPool)
}

func NewWorker(WorkerPool chan chan Job, id int) Worker {
	fmt.Printf("new a worker(%d)\n", id)
	return Worker{
		id:         id,
		WorkerPool: WorkerPool,
		JobChannel: make(chan Job),
		exit:       make(chan bool),
	}
}

// Start 監(jiān)聽任務(wù)和結(jié)束信號
func (w Worker) Start() {
	go func() {
		for {
			select {
			case job := <-w.JobChannel: // 收到任務(wù)
				fmt.Println("get a job from private w.JobChannel")
				fmt.Println(job)
			case <-w.exit: // 收到結(jié)束信號
				fmt.Println("worker exit", w)
				return
			}
		}
	}()
}

func (w Worker) Stop() {
	go func() {
		w.exit <- true
	}()
}

// 排程
func (s *Scheduler) schedule() {
	for {
		select {
		case job := <-JobQueue:
			fmt.Println("get a job from JobQueue")
			go func(job Job) {
				//從WorkerPool獲取jobChannel，忙時阻塞
				jobChannel := <-s.WorkerPool
				fmt.Println("get a private jobChannel from public s.WorkerPool", reflect.TypeOf(jobChannel))
				jobChannel <- job
				fmt.Println("worker's private jobChannel add one job")
			}(job)
		}
	}
}

func main() {
	scheduler := NewScheduler(MaxWorker)
	scheduler.Start()
	jobQueue()
	scheduler.Stop()
}

// 模擬Job任務(wù)
func jobQueue() {
	for i := 1; i <= 30; i++ {
		JobQueue <- Job{ID: i, Name: fmt.Sprintf("Job【%d】", i)}
		fmt.Printf("jobQueue add %d job\n", i)
	}
}