关键词：
worker pool简介
worker pool其实就是线程池thread pool。对于go来说，直接使用的是goroutine而非线程，不过这里仍然以线程来解释线程池。
在线程池模型中，有2个队列一个池子：任务队列、已完成任务队列和线程池。其中已完成任务队列可能存在也可能不存在，依据实际需求而定。
只要有任务进来，就会放进任务队列中。只要线程执行完了一个任务，就将任务放进已完成任务队列，有时候还会将任务的处理结果也放进已完成队列中。
worker pool中包含了一堆的线程(worker，对go而言每个worker就是一个goroutine)，这些线程嗷嗷待哺，等待着为它们分配任务，或者自己去任务队列中取任务。取得任务后更新任务队列，然后执行任务，并将执行完成的任务放进已完成队列。
下图来自wiki：
在Go中有两种方式可以实现工作池：传统的互斥锁、channel。
传统互斥锁机制的工作池
假设Go中的任务的定义形式为：
type Task struct
...
每次有任务进来时，都将任务放在任务队列中。
使用传统的互斥锁方式实现，任务队列的定义结构大概如下：
type Queue struct
M sync.Mutex
Tasks []Task
然后在执行任务的函数中加上Lock()和Unlock()。例如：
func Worker(queue *Queue)
for
// Lock()和Unlock()之间的是critical section
queue.M.Lock()
// 取出任务
task := queue.Tasks[0]
// 更新任务队列
queue.Tasks = queue.Tasks[1:]
queue.M.Unlock()
// 在此goroutine中执行任务
process(task)
假如在线程池中激活了100个goroutine来执行Worker()。Lock()和Unlock()保证了在同一时间点只能有一个goroutine取得任务并随之更新任务列表，取任务和更新任务队列都是critical section中的代码，它们是具有原子性。然后这个goroutine可以执行自己取得的任务。于此同时，其它goroutine可以争夺互斥锁，只要争抢到互斥锁，就可以取得任务并更新任务列表。当某个goroutine执行完process(task)，它将因为for循环再次参与互斥锁的争抢。
上面只是给出了一点主要的代码段，要实现完整的线程池，还有很多额外的代码。
通过互斥锁，上面的一切操作都是线程安全的。但问题在于加锁/解锁的机制比较重量级，当worker(即goroutine)的数量足够多，锁机制的实现将出现瓶颈。
通过buffered channel实现工作池
在Go中，也能用buffered channel实现工作池。
示例代码很长，所以这里先拆分解释每一部分，最后给出完整的代码段。
在下面的示例中，每个worker的工作都是计算每个数值的位数相加之和。例如给定一个数值234，worker则计算2+3+4=9。这里交给worker的数值是随机生成的[0,999)范围内的数值。
这个示例有几个核心功能需要先解释，也是通过channel实现线程池的一般功能：
- 创建一个task buffered channel，并通过allocate()函数将生成的任务存放到task buffered channel中
- 创建一个goroutine pool，每个goroutine监听task buffered channel，并从中取出任务
- goroutine执行任务后，将结果写入到result buffered channel中
- 从result buffered channel中取出计算结果并输出
首先，创建Task和Result两个结构，并创建它们的通道：
type Task struct
ID int
randnum int
type Result struct
task Task
result int
var tasks = make(chan Task, 10)
var results = make(chan Result, 10)这里，每个Task都有自己的ID，以及该任务将要被worker计算的随机数。每个Result都包含了worker的计算结果result以及这个结果对应的task，这样从Result中就可以取出任务信息以及计算结果。
另外，两个通道都是buffered channel，容量都是10。每个worker都会监听tasks通道，并取出其中的任务进行计算，然后将计算结果和任务自身放进results通道中。
然后是计算位数之和的函数process()，它将作为worker的工作任务之一。
func process(num int) int
sum := 0
for num != 0
digit := num % 10
sum += digit
num /= 10
time.Sleep(2 * time.Second)
return sum
这个计算过程其实很简单，但随后还睡眠了2秒，用来假装执行一个计算任务是需要一点时间的。
然后是worker()，它监听tasks通道并取出任务进行计算，并将结果放进results通道。
func worker(wg *WaitGroup)
defer wg.Done()
for task := range tasks
result := Resulttask, process(task.randnum)
results <- result
上面的代码很容易理解，只要tasks channel不关闭，就会一直监听该channel。需要注意的是，该函数使用指针类型的*WaitGroup作为参数，不能直接使用值类型的WaitGroup作为参数，这样会使得每个worker都有一个自己的WaitGroup。
然后是创建工作池的函数createWorkerPool()，它有一个数值参数，表示要创建多少个worker。
func createWorkerPool(numOfWorkers int)
var wg sync.WaitGroup
for i := 0; i < numOfWorkers; i++
wg.Add(1)
go worker(&wg)
wg.Wait()
close(results)
创建工作池时，首先创建一个WaitGroup的值wg，这个wg被工作池中的所有goroutine共享，每创建一个goroutine都wg.Add(1)。创建完所有的goroutine后等待所有的groutine都执行完它们的任务，只要有一个任务还没有执行完，这个函数就会被Wait()阻塞。当所有任务都执行完成后，关闭results通道，因为没有结果再需要向该通道写了。
当然，这里是否需要关闭results通道，是由稍后的range迭代这个通道决定的，不关闭这个通道会一直阻塞range，最终导致死锁。
工作池部分已经完成了。现在需要使用allocate()函数分配任务：生成一大堆的随机数，然后将Task放进tasks通道。该函数有一个代表创建任务数量的数值参数：
func allocate(numOfTasks int)
for i := 0; i < numOfTasks; i++
randnum := rand.Intn(999)
task := Taski, randnum
tasks <- task
close(tasks)
注意，最后需要关闭tasks通道，因为所有任务都分配完之后，没有任务再需要分配。当然，这里之所以需要关闭tasks通道，是因为worker()中使用了range迭代tasks通道，如果不关闭这个通道，worker将在取完所有任务后一直阻塞，最终导致死锁。
再接着的是取出results通道中的结果进行输出，函数名为getResult()：
func getResult(done chan bool)
for result := range results
fmt.Printf("Task id %d, randnum %d , sum %d
", result.task.id, result.task.randnum, result.result)
done <- true
getResult()中使用了一个done参数，这个参数是一个信号通道，用来表示results中的所有结果都取出来并处理完成了，这个通道不一定要用bool类型，任何类型皆可，它不用来传数据，仅用来返回可读，所以上面直接close(done)的效果也一样。通过下面的main()函数，就能理解done信号通道的作用。
最后还差main()函数：
func main()
// 记录起始终止时间，用来测试完成所有任务耗费时长
startTime := time.Now()
numOfWorkers := 20
numOfTasks := 100
// 创建任务到任务队列中
go allocate(numOfTasks)
// 创建工作池
go createWorkerPool(numOfWorkers)
// 取得结果
var done = make(chan bool)
go getResult(done)
// 如果results中还有数据，将阻塞在此
// 直到发送了信号给done通道
<- done
endTime := time.Now()
diff := endTime.Sub(startTime)
fmt.Println("total time taken ", diff.Seconds(), "seconds")
上面分配了20个worker，这20个worker总共需要处理的任务数量为100。但注意，无论是tasks还是results通道，容量都是10，意味着任务队列最长只能是10个任务。
下面是完整的代码段：
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
type Task struct
id int
randnum int
type Result struct
task Task
result int
var tasks = make(chan Task, 10)
var results = make(chan Result, 10)
func process(num int) int
sum := 0
for num != 0
digit := num % 10
sum += digit
num /= 10
time.Sleep(2 * time.Second)
return sum
func worker(wg *sync.WaitGroup)
defer wg.Done()
for task := range tasks
result := Resulttask, process(task.randnum)
results <- result
func createWorkerPool(numOfWorkers int)
var wg sync.WaitGroup
for i := 0; i < numOfWorkers; i++
wg.Add(1)
go worker(&wg)
wg.Wait()
close(results)
func allocate(numOfTasks int)
for i := 0; i < numOfTasks; i++
randnum := rand.Intn(999)
task := Taski, randnum
tasks <- task
close(tasks)
func getResult(done chan bool)
for result := range results
fmt.Printf("Task id %d, randnum %d , sum %d
", result.task.id, result.task.randnum, result.result)
done <- true
func main()
startTime := time.Now()
numOfWorkers := 20
numOfTasks := 100
var done = make(chan bool)
go getResult(done)
go allocate(numOfTasks)
go createWorkerPool(numOfWorkers)
// 必须在allocate()和getResult()之后创建工作池
<-done
endTime := time.Now()
diff := endTime.Sub(startTime)
fmt.Println("total time taken ", diff.Seconds(), "seconds")
执行结果：
Task id 19, randnum 914 , sum 14
Task id 9, randnum 150 , sum 6
Task id 15, randnum 215 , sum 8
............
Task id 97, randnum 315 , sum 9
Task id 99, randnum 641 , sum 11
total time taken 10.0174705 seconds总共花费10秒。
可以试着将任务数量、worker数量修改修改，看看它们的性能比例情况。例如，将worker数量设置为99，将需要4秒，将worker数量设置为10，将需要20秒。
python-线程池的两种实现方式转载(代码片段)
1#!/usr/bin/envpython2#-*-coding:utf-8-*-34importqueue5importthreading6importcontextlib7importtime89StopEvent=object()101112classThreadPool(object):1314def__init__(self,max_num,max_task_num=None):15if 查看详情
go基础系列：go接口(代码片段)
接口用法简介接口(interface)是一种类型，用来定义行为(方法)。typeNamerinterfacemy_method1()my_method2(para)my_method3(para)return_type...但这些行为不会在接口上直接实现，而是需要用户自定义的方法来实现。所以，在上面的Namer接口类型中的... 查看详情
go基础系列：接口类型探测和type-switch(代码片段)
接口类型探测：类型断言接口实例中存储了实现接口的类型实例，类型的实例有两种：值类型实例和指针类型实例。在程序运行过程中，接口实例存储的实例类型可能会动态改变。例如：//ins是接口实例varinsShaper//ins存储值类型... 查看详情
go基础系列：常量和变量(代码片段)
常量(Constants)和iota常量包含不会发生更改的数据。常量的数据类型只能是boolean、number(int/float/complex)或string。定义方式：constNAME[TYPE]=VALUETYPE基本可以省略，因为常量都是简单数据类型，编译器可以根据值推断出它的数据类型。例... 查看详情
go语言实现学生管理系统(代码片段)
介绍总结go语言的基础学习，通过两种方式实现简单的学生信息管理系统方法一packagemainimport( "fmt" "os")//定义所有学生信息varstudentDatamap[int]*student//定义学生typestudentstruct idint64 namestring scoreint//初始化分配内存空间f... 查看详情
go基础系列：数据类型转换(strconv包)(代码片段)
Go不会对数据进行隐式的类型转换，只能手动去执行转换操作。简单的转换操作转换数据类型的方式很简单。valueOfTypeB=typeB(valueOfTypeA)例如：//浮点数a:=5.0//转换为int类型b:=int(a)Go允许在底层结构相同的两个类型之间互转。例如：//... 查看详情
go基础系列：map类型(代码片段)
Go里的map用于存放key/value对，在其它地方常称为hash、dictionary、关联数组，这几种称呼都是对同一种数据结构的不同称呼，它们都用于将key经过hash函数处理，然后映射到value，实现一一对应的关系。map的内部结构一个简单的map结... 查看详情
go基础系列第二章go函数和指针(代码片段)
1.函数2.指针 一.函数 二.指针先来看一段代码varaint=2varpa*intpa=&a*pa=3fmt.Println(a)这里定义了一个int类型的变量a,有定义了一个指针类型的变量pa,让pa指向了a的地址.然后修改了pa的值,我们看看打印出来的a是什么:结... 查看详情
go基础系列：指定goroutine的执行顺序(代码片段)
Gochannel系列：channel入门为select设置超时时间nilchannel用法示例双层channel用法示例指定goroutine的执行顺序当关闭一个channel时，会使得这个channel变得可读。通过这个特性，可以实现一个goroutine执行顺序的技巧。如果一个goroutineA依赖... 查看详情
go语言系列之数组和切片(代码片段)
...文章》Go语言系列(一)之Go的安装和使用Go语言系列(二)之基础语法总结1.数组数组用于存储若干个相同类型的变量的集合。数组中每个变量称为数组的元素，每个元素都有一个数字编号——数组下标，该下标从0开始，用于区别各... 查看详情
go语言实现简单的学生管理系统(代码片段)
介绍总结go语言的基础学习，通过两种方式实现简单的学生信息管理系统方法一packagemainimport( "fmt" "os")//定义所有学生信息varstudentDatamap[int]*student//定义学生typestudentstruct idint64 namestring scoreint//初始化分配内存空间f... 查看详情
go基础系列：流程控制结构(代码片段)
条件判断结构：ifelse分支选择结构：switchcase循环结构：forbreak：退出for或switch结构(以及select)continue：进入下一次for迭代虽然Go是类C的语言，但Go在这些流程控制语句中的条件表达式部分不使用括号。甚至有些时候使用括号会报错... 查看详情
go+系列数组集合基础篇(代码片段)
一、GO的代码的数组如果我们想要用GO语言去完成一个数组的初始化并且赋值的话是比较繁琐的，他需要的代码如下：packagemainimport"fmt"funcmain()a:=[]float641,2,3.4fmt.Println(a)而我们使用GO+的话就仅仅只这样写：a:... 查看详情
go语言系列之并发编程(代码片段)
Go语言中的并发编程并发与并行并发：同一时间段内执行多个任务（你在用微信和两个女朋友聊天）。并行：同一时刻执行多个任务（你和你朋友都在用微信和女朋友聊天）。Go语言的并发通过goroutine实现。goroutine类似于线程，... 查看详情
go--并发编程的两种限速方法
引子golang提供了goroutine快速实现并发编程，在实际环境中，如果goroutine中的代码要消耗大量资源时（CPU、内存、带宽等），我们就需要对程序限速，以防止goroutine将资源耗尽。以下面伪代码为例，看看goroutine如何拖垮一台DB。假... 查看详情
go基础系列：channel入门(代码片段)
channel基础channel用于goroutines之间的通信，让它们之间可以进行数据交换。像管道一样，一个goroutine_A向channel_A中放数据，另一个goroutine_B从channel_A取数据。channel是指针类型的数据类型，通过make来分配内存。例如：ch:=make(chanint)这... 查看详情
带你学够浪：go语言基础系列-10分钟学方法和接口(代码片段)
...足80%的使用需求，剩下在使用中掌握。基于这一理论，Go基础系列的文章不会刻意追求面面俱到，但该有知识点都会覆盖，目的是带你快跑赶上Golang这趟新车。最近工作上和生活上的事情都很多，这篇文章计划是周末发的， 查看详情
go基础系列：struct和嵌套struct(代码片段)
structstruct定义结构，结构由字段(field)组成，每个field都有所属数据类型，在一个struct中，每个字段名都必须唯一。说白了就是拿来存储数据的，只不过可自定义化的程度很高，用法很灵活，Go中不少功能依赖于结构，就这样一个... 查看详情