Add：新增文章<如何实现一个协程池>

Author: iswbm

README.md

@@ -43,7 +43,7 @@
 - 4.6 [学习 Go 协程：互斥锁和读写锁](http://golang.iswbm.com/en/latest/c04/c04_06.html)
 - 4.8 [学习一些常见的并发模型](http://golang.iswbm.com/en/latest/c04/c04_08.html)
 - 4.9 [理解 Go 语言中的 Context](http://golang.iswbm.com/en/latest/c04/c04_09.html)
-- 4.10 [函数式编程](http://golang.iswbm.com/en/latest/c04/c04_10.html)
+- 4.10 [如何实现一个协程池？](http://golang.iswbm.com/en/latest/c04/c04_10.html)
 
 ## 第五章：Web实战
 - 5.1 [Gin 实战：Hello World](http://golang.iswbm.com/en/latest/c05/c05_01.html)

source/c04/c04_09.md

@@ -2,9 +2,9 @@
 
 ## 1. 什么是 Context？
 
-在 go 1.7 版本之前，context 还是非编制的，它存在于 golang.org/x/net/context 包中。
+在 Go 1.7 版本之前，context 还是非编制的，它存在于 golang.org/x/net/context 包中。
 
-后来，golang 团队发现 context 还挺好用的，就把 context 收编了，在 go 1.7 版本正式纳入了标准库。
+后来，Golang 团队发现 context 还挺好用的，就把 context 收编了，在 Go 1.7 版本正式纳入了标准库。
 
 Context，也叫上下文，它的接口定义如下
 
@@ -74,7 +74,7 @@ func main() {
 
 > chan+select的方式，是比较优雅的结束一个goroutine的方式，不过这种方式也有局限性，如果有很多goroutine都需要控制结束怎么办呢？如果这些goroutine又衍生了其他更多的goroutine怎么办呢？如果一层层的无穷尽的goroutine呢？这就非常复杂了，即使我们定义很多chan也很难解决这个问题，因为goroutine的关系链就导致了这种场景非常复杂。
 
-在这里我不是很赞同他说的话，因为我觉得就算只使用一个通道也能控制（取消）多个 goroutine 的目的。下面就用例子来验证一下。
+在这里我不是很赞同他说的话，因为我觉得就算只使用一个通道也能达到控制（取消）多个 goroutine 的目的。下面就用例子来验证一下。
 
 该例子的原理是：使用 close 关闭通道后，如果该通道是无缓冲的，则它会从原来的阻塞变成非阻塞，也就是可读的，只不过读到的会一直是零值，因此根据这个特性就可以判断 拥有该通道的 goroutine 是否要关闭。
 
@@ -235,7 +235,7 @@ cancel()
 
 创建 Context 必须要指定一个 父 Context，当我们要创建第一个Context时该怎么办呢？
 
-不用担心，Go 已经帮我们实现了2个，我们代码中最开始都是以这两个内置的作为最顶层的partent context，衍生出更多的子Context。
+不用担心，Go 已经帮我们实现了2个，我们代码中最开始都是以这两个内置的context作为最顶层的parent context，衍生出更多的子Context。
 
 ```go
 var (

source/c04/c04_09.rst

@@ -4,10 +4,10 @@
 1. 什么是 Context？
 -------------------
 
-在 go 1.7 版本之前，context 还是非编制的，它存在于
+在 Go 1.7 版本之前，context 还是非编制的，它存在于
 golang.org/x/net/context 包中。
 
-后来，golang 团队发现 context 还挺好用的，就把 context 收编了，在 go 1.7
+后来，Golang 团队发现 context 还挺好用的，就把 context 收编了，在 Go 1.7
 版本正式纳入了标准库。
 
 Context，也叫上下文，它的接口定义如下
@@ -87,7 +87,7 @@ Context，也叫上下文，它的接口定义如下
 
    chan+select的方式，是比较优雅的结束一个goroutine的方式，不过这种方式也有局限性，如果有很多goroutine都需要控制结束怎么办呢？如果这些goroutine又衍生了其他更多的goroutine怎么办呢？如果一层层的无穷尽的goroutine呢？这就非常复杂了，即使我们定义很多chan也很难解决这个问题，因为goroutine的关系链就导致了这种场景非常复杂。
 
-在这里我不是很赞同他说的话，因为我觉得就算只使用一个通道也能控制（取消）多个
+在这里我不是很赞同他说的话，因为我觉得就算只使用一个通道也能达到控制（取消）多个
 goroutine 的目的。下面就用例子来验证一下。
 
 该例子的原理是：使用 close
@@ -261,7 +261,7 @@ cancel 就是我们在创建 ctx 的时候返回的第二个值。
 Context，当我们要创建第一个Context时该怎么办呢？
 
 不用担心，Go
-已经帮我们实现了2个，我们代码中最开始都是以这两个内置的作为最顶层的partent
+已经帮我们实现了2个，我们代码中最开始都是以这两个内置的context作为最顶层的parent
 context，衍生出更多的子Context。
 
 .. code:: go

source/c04/c04_10.md

@@ -1,12 +1,40 @@
-# 4.10 函数式编程
+# 4.10 如何实现一个协程池？
 
-函数是一等公民，它可以做为参数进行传递，可以做为函数返回值，也可以做为接收者。所以后来才有了高阶函数，闭包。
+协程池的实现
 
+```go
+type Pool struct {
+  work chan func() // 任务  sem  chan struct{} // 数量
+}
+func New(size int) *Pool {
+    return &Pool{
+        work: make(chan func()),
+        sem:  make(chan struct{}, size),
+    }
+}
+func (p *Pool) Schedule(task func()) error { // 任务调度
+    select {
+    case p.work <- task:
+    case p.sem <- struct{}{}:
+        go p.worker(task)
+    }
+}
+func (p *Pool) worker(task func()) { // 任务执行
+    defer func() { <-p.sem }
+    for {
+        task()
+        task = <-p.work
+    }
+}
 
+```
 
-正统的函数式编程
-
-- 不可变性：不能有状态，只能有函数和变量
-- 函数只能有一个参数
+协程池的调用
 
+```go
+pool := gopool.New(128)
+pool.Schedule(func(){
+  fmt.println("task run")
+})
+```
 

source/c04/c04_10.rst

@@ -1,9 +1,39 @@
-4.10 函数式编程
-===============
+4.10 如何实现一个协程池？
+=========================
 
-函数是一等公民，它可以做为参数进行传递，可以做为函数返回值，也可以做为接收者。所以后来才有了高阶函数，闭包。
+协程池的实现
 
-正统的函数式编程
+.. code:: go
 
--  不可变性：不能有状态，只能有函数和变量
--  函数只能有一个参数
+   type Pool struct {
+     work chan func() // 任务  sem  chan struct{} // 数量
+   }
+   func New(size int) *Pool {
+       return &Pool{
+           work: make(chan func()),
+           sem:  make(chan struct{}, size),
+       }
+   }
+   func (p *Pool) Schedule(task func()) error { // 任务调度
+       select {
+       case p.work <- task:
+       case p.sem <- struct{}{}:
+           go p.worker(task)
+       }
+   }
+   func (p *Pool) worker(task func()) { // 任务执行
+       defer func() { <-p.sem }
+       for {
+           task()
+           task = <-p.work
+       }
+   }
+
+协程池的调用
+
+.. code:: go
+
+   pool := gopool.New(128)
+   pool.Schedule(func(){
+     fmt.println("task run")
+   })