簡書不維護了，歡迎關注我的知乎：波羅學的個人主頁
這篇文章較長將會分兩篇來翻譯。原文地址：https://blog.golang.org/pipelines
介紹
Go并發模型使構建能有效利用IO和多核CPU的實時流式數據的pipeline非常方便。這篇文章將對此進行介紹，同時會著重強調一些在實踐中的易犯錯誤以及對應的解決方法。
什么是Pipeline
在GO中，pipeline無明確定義；它是語言提供的一種并發編程方式，由連接各個chanel而形成的一系列階段組成。在其各個階段，可能分別運行著很多的goroutine。這些goroutine
- 從輸入channel接收數據
- 對數據作相應處理，例如在此基礎上產生新數據
- 再通過輸出channel把數據發送出去
除了開始和結束，每個階段都會包含任意多個輸入和輸出channel。開始階段只有輸出channel，結束階段只有輸入channel。相應地，開始階段可被稱為生產者，結束階段可被稱為消費者。
我們先通過一個簡單的例子來說明。
并發計算平方數
首先來舉一個三階段pipeline的例子
第一階段，創建輸入參數為可變長int整數的gen函數，它通過goroutine發送所有輸入參數，并在發送完成后關閉相應channel：
func gen(nums ...int) <-chan int {
out := make(chan int)
go func() {
for _, n := range nums {
out <- n
}
close(out)
}()
reutrn out
}
第二階段，sq函數，負責從輸入channel中接收數據并作平方處理再發送到輸出channel中。在輸入channel關閉并把所有數據都成功發送至輸出channel，關閉輸出channel：
func sq(in <-chan int) <-chan int {
out := make(chan int)
go func() {
for n := range in {
out <- n * n
}
close(out)
}()
return out
}
主函數main中創建了pipeline，并執行了最后階段的任務，從管道中接收了第二階段的數據并打印了出來：
func main() {
// Set up the pipeline
c := gen(2, 3)
out := sql(c)
// Consume the output
fmt.Println(<-out)
fmt.Println(<-out)
}
此處sq函數的輸入和輸出參數為相同類型的channel，因此我們可以對其進行組合。重寫main函數，如下：
func main() {
// Set up the pipeline and consume the output.
for n := range sq(sq(gen(2, 3))) {
fmt.Println(n)
}
}
此處相等于在pipeline中增加了一個階段，即涉及到了三個階段，其中2、3階段的goroutine由同一函數產生。
Fan-out和Fan-in (扇出和扇入)
多個函數可同時從同一個channel中讀取數據，直到channel關閉，稱為fan-out。這為我們提供了一種將任務分發給多個worker的途徑，從而實現CPU和I/O的高效利用。
通過多路復用技術將多個channel合并到單個channel實現從多個輸入讀取數據的能力，只有當所有的輸入都關閉，才會停止數據的讀取。這個稱作 fan-in。
重寫之前的main，我們調用兩次sq，且兩次都從同一個channel中讀取數據。我們將引入一個新的函數，通過fan-in方式獲取數據：
func main() {
in := gen(2, 3)
// Distribute the sq work across two goroutines that both read from in
c1 := sq(in)
c2 := sq(in)
// Comsume the merged output from c1 and c2
for n := range merge(c1, c2) {
fmt.Println(n) // 4 then 9, or 9 then 4
}
}
merge函數通過為每個輸入channel啟動一個goroutine實現將數據發送同一個channel中，從完成將channel列表轉化為單個channel的功能。一旦所有的輸出channel（生產者）啟動，merge就會啟動一或多個goroutine接收所有數據并在結束后關閉對應channel。
在已關閉的channel發送數據會導致panic，因此保證關閉channel前所有數據都發送完畢是非常重要的。sync.WaitGroup為我們提供了一種實現該同步的方式。示例如下：
func merge(cs ...<-chan int) <-chan int {
var wg sync.WaitGroup
out := make(chan int)
output := func(c <-chan int) {
for n := range c {
out <- n
}
wg.Done()
}
wg.Add(len(cs)
for _, c := range(cs) {
go output(c)
}
// Start a goroutine to close out once all the output goroutines are
// done. This must start after the wg.Add call.
go func() {
wg.Wait()
close(out)
}()
return out
}
goroutine突然停止
一些使用原則：
- 在數據發送完畢后，關閉輸出channel；
- 持續不停地從輸入中接收數據，直到channel關閉;
我們可使用for循環來接收數據，一旦數據所有數據接收完畢將會自動退出。
但在真實場景中，并非所有情況都需要接收完所有的數據。有時設計如此，我們只需一部分的數據并可運行。更常見地，如果輸入早早就拋出了一個錯誤，這時該階段便會早早地退出。還有一些情況，如接收者不再等待數據接收，此時也需停止數據的生產。
在我們的例子中，如果一個階段沒有成功接收完數據就退出，我們的goroutine仍會嘗試發送數據，這將會導致channel進入無限期的阻塞。
func main() {
// Consume the first value from the output
out := merge(c1, c2)
fmt.Println(<-out)
return
// Since we didn't receive the second value from out,
// one of the output goroutine is hung attempting to send it
}
這是資源泄露：goroutine會繼續消耗內存、運行時資源，而且在棧中的堆引用也不能被回收。goroutine必須退出，才能啟動垃圾回收機制。
當下游不能完全接收所有數據時，我們需要準備將上游goroutine退出。一種方式，我們可以把上游的channel設定為一個buffer。當buffer還有空間時，發送操作將會立刻完成。
c := make(chan int, 2)
c <- 1 // succeeds immediately
c <- 2 // succeeds immediately
c <- 3 // blocks until another goroutine does <-c and receives 1
當channel被創建時，如果我們已經知道數據的大小，可以如此來簡化我們的代碼。比如，我們重寫gen函數，拷貝數據到buffer channel中，可以避免創建新的goroutine。
func gen(nums ...int) int {
out := make(chan int, len(nums))
for _, n := range nums {
out <- n
}
close(out)
return out
}
我們可以考慮給merge函數輸出channel指定固定大小空間。
func merge(cs ...<-chan int) <-chan int {
var wg sync.WaitGroup
out := make(chan, int, 1) // enough space for the unread inputs
// ... the rest is unchanged ...
}
雖然這解決了程序中goroutine阻塞的問題，但并不是好代碼。指定buffer的長度我們需知道merge將接收值的數量。如果下游讀取少量數據便結束，依然會阻塞。
我們需要一種方式，使下游通知上游以表明它們不再接收信息。
