第十四章上半部分 (#836)

Co-authored-by: Joe Chen <jc@unknwon.io>
2025-08-12 05:11:49 +08:00 · 2022-05-17 16:24:13 +08:00
parent 92d91dfa1c
commit f08d76efa6
11 changed files with 112 additions and 114 deletions
--- a/eBook/14.2.md
+++ b/eBook/14.2.md
@@ -14,11 +14,11 @@

 通常使用这样的格式来声明通道：`var identifier chan datatype`

-未初始化的通道的值是 nil 。
+未初始化的通道的值是 `nil`。

 所以通道只能传输一种类型的数据，比如 `chan int` 或者 `chan string`，所有的类型都可以用于通道，空接口 `interface{}` 也可以，甚至可以（有时非常有用）创建通道的通道。

-通道实际上是类型化消息的队列：使数据得以传输。它是先进先出（FIFO）的结构所以可以保证发送给他们的元素的顺序（有些人知道，通道可以比作 Unix shells 中的双向管道（two-way pipe））。通道也是引用类型，所以我们使用 `make()` 函数来给它分配内存。这里先声明了一个字符串通道 ch1，然后创建了它（实例化）：
+通道实际上是类型化消息的队列：使数据得以传输。它是先进先出(FIFO) 的结构所以可以保证发送给他们的元素的顺序（有些人知道，通道可以比作 Unix shells 中的双向管道 (two-way pipe) ）。通道也是引用类型，所以我们使用 `make()` 函数来给它分配内存。这里先声明了一个字符串通道 ch1，然后创建了它（实例化）：

 ```go
 var ch1 chan string
@@ -39,11 +39,11 @@ ch1 = make(chan string)

 流向通道（发送）

-`ch <- int1` 表示：用通道 ch 发送变量 int1（双目运算符，中缀 = 发送）
+`ch <- int1` 表示：用通道 `ch` 发送变量 `int1`（双目运算符，中缀 = 发送）

 从通道流出（接收），三种方式：

-`int2 = <- ch` 表示：变量 int2 从通道 ch（一元运算的前缀操作符，前缀 = 接收）接收数据（获取新值）；假设 int2 已经声明过了，如果没有的话可以写成：`int2 := <- ch`。
+`int2 = <- ch` 表示：变量 `int2` 从通道 ch（一元运算的前缀操作符，前缀 = 接收）接收数据（获取新值）；假设 `int2` 已经声明过了，如果没有的话可以写成：`int2 := <- ch`。

 `<- ch` 可以单独调用获取通道的（下一个）值，当前值会被丢弃，但是可以用来验证，所以以下代码是合法的：

@@ -106,15 +106,15 @@ Washington Tripoli London Beijing tokyo

 我们发现协程之间的同步非常重要：

- main() 等待了 1 秒让两个协程完成，如果不这样，sendData() 就没有机会输出。
- getData() 使用了无限循环：它随着 sendData() 的发送完成和 ch 变空也结束了。
+- `main()` 等待了 1 秒让两个协程完成，如果不这样，`sendData()` 就没有机会输出。
+- `getData()` 使用了无限循环：它随着 `sendData()` 的发送完成和 `ch` 变空也结束了。
 - 如果我们移除一个或所有 `go` 关键字，程序无法运行，Go 运行时会抛出 panic：

 ```
 ---- Error run E:/Go/Goboek/code examples/chapter 14/goroutine2.exe with code Crashed ---- Program exited with code -2147483645: panic: all goroutines are asleep-deadlock!
 ```

-为什么会这样？运行时（runtime）会检查所有的协程（像本例中只有一个）是否在等待着什么东西（可从某个通道读取或者写入某个通道），这意味着程序将无法继续执行。这是死锁（deadlock）的一种形式，而运行时（runtime）可以为我们检测到这种情况。
+为什么会这样？运行时 (runtime) 会检查所有的协程（像本例中只有一个）是否在等待着什么东西（可从某个通道读取或者写入某个通道），这意味着程序将无法继续执行。这是死锁 (deadlock) 的一种形式，而运行时 (runtime) 可以为我们检测到这种情况。

 注意：不要使用打印状态来表明通道的发送和接收顺序：由于打印状态和通道实际发生读写的时间延迟会导致和真实发生的顺序不同。

@@ -124,13 +124,13 @@ Washington Tripoli London Beijing tokyo

 默认情况下，通信是同步且无缓冲的：在有接受者接收数据之前，发送不会结束。可以想象一个无缓冲的通道在没有空间来保存数据的时候：必须要一个接收者准备好接收通道的数据然后发送者可以直接把数据发送给接收者。所以通道的发送/接收操作在对方准备好之前是阻塞的：

-1）对于同一个通道，发送操作（协程或者函数中的），在接收者准备好之前是阻塞的：如果 ch 中的数据无人接收，就无法再给通道传入其他数据：新的输入无法在通道非空的情况下传入。所以发送操作会等待 ch 再次变为可用状态：就是通道值被接收时（可以传入变量）。
+1）对于同一个通道，发送操作（协程或者函数中的），在接收者准备好之前是阻塞的：如果 `ch` 中的数据无人接收，就无法再给通道传入其他数据：新的输入无法在通道非空的情况下传入。所以发送操作会等待 `ch` 再次变为可用状态：就是通道值被接收时（可以传入变量）。

 2）对于同一个通道，接收操作是阻塞的（协程或函数中的），直到发送者可用：如果通道中没有数据，接收者就阻塞了。

 尽管这看上去是非常严格的约束，实际在大部分情况下工作的很不错。

-程序 [channel_block.go](examples/chapter_14/channel_block.go) 验证了以上理论，一个协程在无限循环中给通道发送整数数据。不过因为没有接收者，只输出了一个数字 0。
+程序 [channel_block.go](examples/chapter_14/channel_block.go) 验证了以上理论，一个协程在无限循环中给通道发送整数数据。不过因为没有接收者，只输出了一个数字 `0`。

 示例 14.3-[channel_block.go](examples/chapter_14/channel_block.go)

@@ -160,7 +160,7 @@ func pump(ch chan int) {

 `pump()` 函数为通道提供数值，也被叫做生产者。

-为通道解除阻塞定义了 `suck` 函数来在无限循环中读取通道，参见示例 14.4-[channel_block2.go](examples/chapter_14/channel_block2.go)：
+为通道解除阻塞定义了 `suck()` 函数来在无限循环中读取通道，参见示例 14.4-[channel_block2.go](examples/chapter_14/channel_block2.go)：

 ```go
 func suck(ch chan int) {
@@ -183,9 +183,9 @@ time.Sleep(1e9)

 ## 14.2.4 通过一个（或多个）通道交换数据进行协程同步。

-通信是一种同步形式：通过通道，两个协程在通信（协程会和）中某刻同步交换数据。无缓冲通道成为了多个协程同步的完美工具。
+通信是一种同步形式：通过通道，两个协程在通信（协程会合）中某刻同步交换数据。无缓冲通道成为了多个协程同步的完美工具。

-甚至可以在通道两端互相阻塞对方，形成了叫做死锁的状态。Go 运行时会检查并 panic，停止程序。死锁几乎完全是由糟糕的设计导致的。
+甚至可以在通道两端互相阻塞对方，形成了叫做**死锁**的状态。Go 运行时会检查并 `panic()`，停止程序。死锁几乎完全是由糟糕的设计导致的。

 无缓冲通道会被阻塞。设计无阻塞的程序可以避免这种情况，或者使用带缓冲的通道。

@@ -220,20 +220,20 @@ buf := 100
 ch1 := make(chan string, buf)
 ```

-buf 是通道可以同时容纳的元素（这里是 string）个数
+`buf` 是通道可以同时容纳的元素（这里是 `string`）个数

 在缓冲满载（缓冲被全部使用）之前，给一个带缓冲的通道发送数据是不会阻塞的，而从通道读取数据也不会阻塞，直到缓冲空了。

-缓冲容量和类型无关，所以可以（尽管可能导致危险）给一些通道设置不同的容量，只要他们拥有同样的元素类型。内置的 `cap` 函数可以返回缓冲区的容量。
+缓冲容量和类型无关，所以可以（尽管可能导致危险）给一些通道设置不同的容量，只要他们拥有同样的元素类型。内置的 `cap()` 函数可以返回缓冲区的容量。

 如果容量大于 0，通道就是异步的了：缓冲满载（发送）或变空（接收）之前通信不会阻塞，元素会按照发送的顺序被接收。如果容量是 0 或者未设置，通信仅在收发双方准备好的情况下才可以成功。

 同步：`ch :=make(chan type, value)`

- value == 0 -> synchronous, unbuffered (阻塞）
- value > 0 -> asynchronous, buffered（非阻塞）取决于 value 元素
+- `value == 0 -> synchronous`, unbuffered （阻塞）
+- `value > 0 -> asynchronous`, buffered（非阻塞）取决于 `value` 元素

-若使用通道的缓冲，你的程序会在“请求”激增的时候表现更好：更具弹性，专业术语叫：更具有伸缩性（scalable）。在设计算法时首先考虑使用无缓冲通道，只在不确定的情况下使用缓冲。
+若使用通道的缓冲，你的程序会在“请求”激增的时候表现更好：更具弹性，专业术语叫：更具有伸缩性(scalable)。在设计算法时首先考虑使用无缓冲通道，只在不确定的情况下使用缓冲。

 练习 14.3：[channel_buffer.go](exercises/chapter_14/channel_buffer.go)：给 [channel_block3.go](exercises/chapter_14/channel_block3.go) 的通道增加缓冲并观察输出有何不同。

@@ -248,15 +248,15 @@ go sum(bigArray, ch) // bigArray puts the calculated sum on ch
 sum := <- ch // wait for, and retrieve the sum
 ```

-也可以使用通道来达到同步的目的，这个很有效的用法在传统计算机中称为信号量（semaphore）。或者换个方式：通过通道发送信号告知处理已经完成（在协程中）。
+也可以使用通道来达到同步的目的，这个很有效的用法在传统计算机中称为信号量 (semaphore)。或者换个方式：通过通道发送信号告知处理已经完成（在协程中）。

-在其他协程运行时让 main 程序无限阻塞的通常做法是在 `main` 函数的最后放置一个 `select {}`。
+在其他协程运行时让 `main` 程序无限阻塞的通常做法是在 `main()` 函数的最后放置一个 `select {}`。

 也可以使用通道让 `main` 程序等待协程完成，就是所谓的信号量模式，我们会在接下来的部分讨论。

 ## 14.2.7 信号量模式

-下边的片段阐明：协程通过在通道 `ch` 中放置一个值来处理结束的信号。`main` 协程等待 `<-ch` 直到从中获取到值。
+下边的片段阐明：协程通过在通道 `ch` 中放置一个值来处理结束的信号。`main()` 协程等待 `<-ch` 直到从中获取到值。

 我们期望从这个通道中获取返回的结果，像这样：

@@ -273,7 +273,7 @@ func main(){
 }
 ```

-这个信号也可以是其他的，不返回结果，比如下面这个协程中的匿名函数（lambda）协程：
+这个信号也可以是其他的，不返回结果，比如下面这个协程中的匿名函数 (lambda) 协程：

 ```go
 ch := make(chan int)
@@ -285,7 +285,7 @@ doSomethingElseForAWhile()
 <- ch	// Wait for goroutine to finish; discard sent value.
 ```

-或者等待两个协程完成，每一个都会对切片 s 的一部分进行排序，片段如下：
+或者等待两个协程完成，每一个都会对切片 `s` 的一部分进行排序，片段如下：

 ```go
 done := make(chan bool)
@@ -301,7 +301,7 @@ go doSort(s[i:])
 <-done
 ```

-下边的代码，用完整的信号量模式对长度为 N 的 float64 切片进行了 N 个 `doSomething()` 计算并同时完成，通道 sem 分配了相同的长度（且包含空接口类型的元素），待所有的计算都完成后，发送信号（通过放入值）。在循环中从通道 sem 不停的接收数据来等待所有的协程完成。
+下边的代码，用完整的信号量模式对长度为 `N` 的 `float64` 切片进行了 `N` 个 `doSomething()` 计算并同时完成，通道 `sem` 分配了相同的长度（且包含空接口类型的元素），待所有的计算都完成后，发送信号（通过放入值）。在循环中从通道 `sem` 不停的接收数据来等待所有的协程完成。

 ```go
 type Empty interface {}
@@ -321,12 +321,11 @@ for i, xi := range data {
 for i := 0; i < N; i++ { <-sem }
 ```

-注意上述代码中闭合函数的用法：`i`、`xi` 都是作为参数传入闭合函数的，这一做法使得每个协程（译者注：在其启动时）获得一份 `i` 和 `xi` 的单独拷贝，从而向闭合函数内部屏蔽了外层循环中的 `i` 和 `xi` 变量；否则，for 循环的下一次迭代会更新所有协程中 `i` 和 `xi` 的值。另一方面，切片 `res` 没有传入闭合函数，因为协程不需要 `res` 的单独拷贝。切片 `res` 也在闭合函数中但并不是参数。
+注意上述代码中闭合函数的用法：`i`、`xi` 都是作为参数传入闭合函数的，这一做法使得每个协程（译者注：在其启动时）获得一份 `i` 和 `xi` 的单独拷贝，从而向闭合函数内部屏蔽了外层循环中的 `i` 和 `xi` 变量；否则，`for` 循环的下一次迭代会更新所有协程中 `i` 和 `xi` 的值。另一方面，切片 `res` 没有传入闭合函数，因为协程不需要 `res` 的单独拷贝。切片 `res` 也在闭合函数中但并不是参数。

+## 14.2.8 实现并行的 `for` 循环

-## 14.2.8 实现并行的 for 循环
-
-在上一部分章节 [14.2.7](14.2.md#1427-信号量模式) 的代码片段中：for 循环的每一个迭代是并行完成的：
+在上一部分章节 [14.2.7](14.2.md#1427-信号量模式) 的代码片段中：`for` 循环的每一个迭代是并行完成的：

 ```go
 for i, v := range data {
@@ -337,7 +336,7 @@ for i, v := range data {
 }
 ```

-在 for 循环中并行计算迭代可能带来很好的性能提升。不过所有的迭代都必须是独立完成的。有些语言比如 Fortress 或者其他并行框架以不同的结构实现了这种方式，在 Go 中用协程实现起来非常容易：
+在 `for` 循环中并行计算迭代可能带来很好的性能提升。不过所有的迭代都必须是独立完成的。有些语言比如 Fortress 或者其他并行框架以不同的结构实现了这种方式，在 Go 中用协程实现起来非常容易：

 ## 14.2.9 用带缓冲通道实现一个信号量

@@ -354,7 +353,7 @@ type Empty interface {}
 type semaphore chan Empty
 ```

-将可用资源的数量N来初始化信号量 `semaphore`：`sem = make(semaphore, N)`
+将可用资源的数量 `N` 来初始化信号量 `semaphore`：`sem = make(semaphore, N)`

 然后直接对信号量进行操作：

@@ -399,9 +398,9 @@ func (s semaphore) Signal() {

 练习 14.5：[gosum.go](exercises/chapter_14/gosum.go)：用这种习惯用法写一个程序，开启一个协程来计算 2 个整数的和并等待计算结果并打印出来。

-练习 14.6：[producer_consumer.go](exercises/chapter_14/producer_consumer.go)：用这种习惯用法写一个程序，有两个协程，第一个提供数字 0，10，20，...90 并将他们放入通道，第二个协程从通道中读取并打印。`main()` 等待两个协程完成后再结束。
+练习 14.6：[producer_consumer.go](exercises/chapter_14/producer_consumer.go)：用这种习惯用法写一个程序，有两个协程，第一个提供数字 0，10，20，...，90 并将他们放入通道，第二个协程从通道中读取并打印。`main()` 等待两个协程完成后再结束。

-习惯用法：通道工厂模式
+**习惯用法：通道工厂模式**

 编程中常见的另外一种模式如下：不将通道作为参数传递给协程，而用函数来生成一个通道并返回（工厂角色）；函数内有个匿名函数被协程调用。

@@ -448,7 +447,7 @@ for v := range ch {
 }
 ```

-它从指定通道中读取数据直到通道关闭，才继续执行下边的代码。很明显，另外一个协程必须写入 `ch`（不然代码就阻塞在 for 循环了），而且必须在写入完成后才关闭。`suck` 函数可以这样写，且在协程中调用这个动作，程序变成了这样：
+它从指定通道中读取数据直到通道关闭，才继续执行下边的代码。很明显，另外一个协程必须写入 `ch`（不然代码就阻塞在 `for` 循环了），而且必须在写入完成后才关闭。`suck()` 函数可以这样写，且在协程中调用这个动作，程序变成了这样：

 示例 14.6-[channel_idiom2.go](examples/chapter_14/channel_idiom2.go)：

@@ -484,9 +483,9 @@ func suck(ch chan int) {
 }
 ```

-习惯用法：通道迭代模式
+**习惯用法：通道迭代器模式**

-这个模式用到了后边 14.6 章示例 [producer_consumer.go](exercises/chapter_14/producer_consumer.go) 的生产者-消费者模式，通常，需要从包含了地址索引字段 items 的容器给通道填入元素。为容器的类型定义一个方法 `Iter()`，返回一个只读的通道（参见第 [14.2.11](14.2.md#14211-通道的方向) 节）items，如下：
+这个模式用到了后边 [14.6 章](14.6.md)示例 [producer_consumer.go](exercises/chapter_14/producer_consumer.go) 的生产者-消费者模式。通常，需要从包含了地址索引字段 `items` 的容器给通道填入元素。为容器的类型定义一个方法 `Iter()`，返回一个只读的通道（参见第 [14.2.11](14.2.md#14211-通道的方向) 节）`items`，如下：

 ```go
 func (c *container) Iter () <- chan item {
@@ -500,7 +499,7 @@ func (c *container) Iter () <- chan item {
 }
 ```

-在协程里，一个 for 循环迭代容器 c 中的元素（对于树或图的算法，这种简单的 for 循环可以替换为深度优先搜索）。
+在协程里，一个 `for` 循环迭代容器 `c` 中的元素（对于树或图的算法，这种简单的 `for` 循环可以替换为深度优先搜索）。

 调用这个方法的代码可以这样迭代容器：

@@ -508,11 +507,11 @@ func (c *container) Iter () <- chan item {
 for x := range container.Iter() { ... }
 ```

-其运行在自己启动的协程中，所以上边的迭代用到了一个通道和两个协程（可能运行在不同的线程上）。 这样我们就有了一个典型的生产者-消费者模式。如果在程序结束之前，向通道写值的协程未完成工作，则这个协程不会被垃圾回收；这是设计使然。这种看起来并不符合预期的行为正是由通道这种线程安全的通信方式所导致的。如此一来，一个协程为了写入一个永远无人读取的通道而被挂起就成了一个 bug ，而并非你预想中的那样被悄悄回收掉（garbage-collected）了。
+其运行在自己启动的协程中，所以上边的迭代用到了一个通道和两个协程（可能运行在不同的线程上）。 这样我们就有了一个典型的生产者-消费者模式。如果在程序结束之前，向通道写值的协程未完成工作，则这个协程不会被垃圾回收；这是设计使然。这种看起来并不符合预期的行为正是由通道这种线程安全的通信方式所导致的。如此一来，一个协程为了写入一个永远无人读取的通道而被挂起就成了一个 bug ，而并非你预想中的那样被悄悄回收掉 (garbage-collected) 了。

-习惯用法：生产者消费者模式
+**习惯用法：生产者消费者模式**

-假设你有 `Produce()` 函数来产生 `Consume` 函数需要的值。它们都可以运行在独立的协程中，生产者在通道中放入给消费者读取的值。整个处理过程可以替换为无限循环：
+假设你有 `Produce()` 函数来产生 `Consume()` 函数需要的值。它们都可以运行在独立的协程中，生产者在通道中放入给消费者读取的值。整个处理过程可以替换为无限循环：

 ```go
 for {
@@ -529,7 +528,7 @@ var send_only chan<- int 		// channel can only receive data
 var recv_only <-chan int		// channel can only send data
 ```

-只接收的通道（<-chan T）无法关闭，因为关闭通道是发送者用来表示不再给通道发送值了，所以对只接收通道是没有意义的。通道创建的时候都是双向的，但也可以分配有方向的通道变量，就像以下代码：
+只接收的通道 (`<-chan T`) 无法关闭，因为关闭通道是发送者用来表示不再给通道发送值了，所以对只接收通道是没有意义的。通道创建的时候都是双向的，但也可以分配给有方向的通道变量，就像以下代码：

 ```go
 var c = make(chan int) // bidirectional
@@ -545,7 +544,7 @@ func sink(ch <-chan int) {
 }
 ```

-习惯用法：管道和选择器模式
+**习惯用法：管道和选择器模式**

 更具体的例子还有协程处理它从通道接收的数据并发送给输出通道：

@@ -610,7 +609,7 @@ func main() {
 }
 ```

-协程 `filter(in, out chan int, prime int)` 拷贝整数到输出通道，丢弃掉可以被 prime 整除的数字。然后每个 prime 又开启了一个新的协程，生成器和选择器并发请求。
+协程 `filter(in, out chan int, prime int)` 拷贝整数到输出通道，丢弃掉可以被 `prime` 整除的数字。然后每个 `prime` 又开启了一个新的协程，生成器和选择器并发请求。

 输出：

@@ -625,7 +624,7 @@ func main() {
 937 941 947 953 967 971 977 983 991 997 1009 1013...
 ```

-第二个版本引入了上边的习惯用法：函数 `sieve`、`generate` 和 `filter` 都是工厂；它们创建通道并返回，而且使用了协程的 lambda 函数。`main` 函数现在短小清晰：它调用 `sieve()` 返回了包含素数的通道，然后通过 `fmt.Println(<-primes)` 打印出来。
+第二个版本引入了上边的习惯用法：函数 `sieve()`、`generate()` 和 `filter()` 都是工厂；它们创建通道并返回，而且使用了协程的 lambda 函数。`main()` 函数现在短小清晰：它调用 `sieve()` 返回了包含素数的通道，然后通过 `fmt.Println(<-primes)` 打印出来。

 版本2：示例 14.8-[sieve2.go](examples/chapter_14/sieve2.go)