Confinement

該模式用於處理資料限制問題，類似於生產者和消費者模式。使用channel的方式通過共享資訊的方式進行。有一個協程專門負責生產，另外一個協程負責接收資料。程式碼中使用隨機的時間模擬實際情況中耗時部分。

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    chanOwner := func(n int) <-chan int {
        results := make(chan int, 5)
        go func() {
            defer
 
 close(results)
            for i := 0; i < n; i++ {
                results <- i
                fmt.Printf("produce %d\n", i)
                t := rand.Intn(2000)
                time.Sleep(time.Duration(t) * time.Millisecond) // 隨機睡眠0-2秒
            }
        }()
        return results
    }

    consumer := func
 
(results <-chan int) {
        for result := range results {
            t := rand.Intn(2000)
            time.Sleep(time.Duration(t) * time.Millisecond) // 隨機睡眠0-2秒
            fmt.Printf("Received %d\n", result)
        }
        fmt.Println("Done receiving")
    }
    results := chanOwner(5)
    consumer(results)
}
/*
程式碼輸出：
produce 0
produce 1
Received 0
produce 2
Received 1
produce 3
produce 4
Received 2
Received 3
Received 4
Done receiving
*/
 

這種模式可以根據實際情況定義生產和消費的方式，不用擔心出現數據競爭的問題。

for-select迴圈

最常規的模式：

for { // 死迴圈
    select {
    // 在這裡採取有關操作
    }
}

通過迭代的方式把資料寫入channel

for _, s := range []string{"a", "b", "c"} {
    select {
    case <-done:  // 這裡是完成條件的標記
        return
    case stringStream <- s:  // 在這裡寫入資料
    }
}

死迴圈等待結束標記。
這種方式會盡可能早的結束工作，只要done訊號到達，立刻終止：

for {
    select {
    case <-done:
        return
    default:
    }
    // do something here
}

另一個等價方式

for {
    select {
    case <-done:
        return
    default:
        // do something here
    }
}

防止goroutine洩露

儘管goroutine是一種輕量級的程序，而且一般不必擔心使用太多的協程導致記憶體的問題，Go語言的有自動回收機制；但是，在某些情況下確實需要考慮出現某些協程一直無法回收的問題，這可還會引發一些其它的不良後果，給出下面的例子：

doWork := func(strings <-chan string) <-chan interface{} {
    completed := make(chan interface{})
    go func() {
        defer fmt.Println("doWork exited")
        defer close(completed)
        for s := range strings {
            // Do something
            fmt.Println(s)
        }
    }()
    return completed
}
doWork(nil)
fmt.Println("Done")

在上述的程式碼中，doWork會永遠阻塞，因為空的string channel不會有任何內容輸出。本例子中的開銷可能很小，但是在實際的工程中，這可能會引發大的問題。解決方法是通過父協程結束子協程。通過父協程給子協程發射終止的訊號，使得子協程自動終止。

給出一般的操作方式：

   doWork := func(
        done <-chan interface{},  // 終止的訊號
        strings <-chan string,    // 等待讀取的字串
    ) <-chan interface{} {        // 子協程返回自己終止的訊號
        terminated := make(chan interface{})
        go func() {
            defer fmt.Println("doWork exited")
            defer close(terminated)
            for {
                select {
                case s := <-strings:
                    // do something
                    fmt.Println(s)
                case <-done:  // 如果關閉，則直接執行return
                    return
                }
            }
        }()
        return terminated
    }

    done := make(chan interface{})
    terminated := doWork(done, nil)  // 接收子協程的終止訊號
    go func() {
        // cancel the operation after 1 second
        time.Sleep(time.Second)
        fmt.Println("Canceling doWork goroutine...")
        close(done)  // 關閉後相當於不存在阻塞的情況了。。。
    }()
    <-terminated  // 在這裡等待子協程的終止
    fmt.Println("Done.")

上述程式碼是讀資料的例子，下面給出寫資料時發生協程洩露的例子：

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    newRandStream := func() <-chan int {
        randStream := make(chan int)
        go func() {
            defer fmt.Println("newRandStream closure exited.")
            defer close(randStream)
            for {
                randStream <- rand.Int()
            }
        }()
        return randStream
    }

    randStream := newRandStream()
    n := 3
    fmt.Printf("%d random ints:\n", n)
    for i := 0; i < n; i++ {
        fmt.Printf("%d: %d\n", i, <-randStream)  // 注意這種使用方式，也是合法的
    }
}
/*
輸出結果：
3 random ints:
0: 5577006791947779410
1: 8674665223082153551
2: 6129484611666145821
*/

上述程式碼中，randStream始終沒有結束，出現了協程洩露。。

改進方案：和寫資料的方式類似，通過父協程給子協程發射結束訊號即可。程式碼方案：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    newRandStream := func(done <-chan interface{}) <-chan int {
        randStream := make(chan int)
        go func() {
            defer fmt.Println("newRandStream closure exited...")
            defer close(randStream)
            for {
                select {
                case randStream <- rand.Int():
                case <-done:
                    return
                }
            }
        }()
        return randStream
    }

    done := make(chan interface{})
    randStream := newRandStream(done)
    n := 3
    fmt.Printf("%d random ints\n", n)
    for i := 0; i < 3; i++ {
        fmt.Printf("%d:%d\n", n, <-randStream)
    }
    close(done)
    // 等待同步看效果，不用等待也可以正常結束的，這裡僅僅是為了顯式說明一下
    time.Sleep(time.Second)
}
/*
輸出結果：
3 random ints
0:5577006791947779410
1:8674665223082153551
2:6129484611666145821
newRandStream closure exited...
*/

or-channel方式

這種模式的方式是：把多個channel的done連線到一個done上，如果這些channel中任何至少一個關閉，則關閉這個done。 程式碼中，如果出現一個任意一個協程結束，那麼就出現終止訊號。終止訊號出現後，如果有協程沒有結束，他們會繼續執行，程式碼只是檢測是否有協程終止，而不主動結束協程。
給出例項程式碼：

package main

import (
    "fmt"
    "time"
)

func main() {
    // 從這裡傳入各個channel的done
    var or func(channels ...<-chan interface{}) <-chan interface{}
    or = func(channels ...<-chan interface{}) <-chan interface{} {
        switch (len(channels)) {
        case 0: // 遞迴結束的條件
            return nil
        case 1: // 只有一個直接返回
            return channels[0]
        }
        orDone := make(chan interface{}) // 這是自己的標記
        // 可以理解成一棵協程樹，父節點需要孩子節點結束才能銷燬。。。
        // 在這裡進行協程孩子節點的拓展，WTF好難理解。。。。。
        // 在匿名函式中，如果一個channel的任何一個子channel結束，那麼匿名函式的阻塞就會立刻結束，
        // 之後會執行內部的defer操作，然後return一個關閉了的channel，相當於解除阻塞
        go func() {
            defer close(orDone) // 結束的時候釋放本身的done訊號
            switch len(channels) {
            case 2:
                select {
                case <-channels[0]:
                case <-channels[1]:
                }
            default:
                select {
                // 如果case失敗，則進行default，需要再判斷一下，防止此次突然有結束的訊號了
                case <-channels[0]:
                case <-channels[1]:
                case <-channels[2]:
                // 在這裡追加父節點的協程終止訊號，因為這是一棵或的樹，只要有一個節點成功就可以釋放掉
                // 因此把父節點一起傳入，只要有一個釋放掉，父節點的channel就立刻進行釋放......好機智的操作
                // 這裡追加自己的orDone，是為了`
                case <-or(append(channels[3:], orDone)...): // 注意使用...符號
                }
            }
        }()
        return orDone
    }

    sig := func(after time.Duration) <-chan interface{} {
        c := make(chan interface{})  
        go func() {
            defer close(c) // 所在的goroutine結束後close，使用時間模擬工作時間
            time.Sleep(after)
        }()
        return c
    }

    start := time.Now()
    <-or(
        sig(2*time.Hour),
        sig(5*time.Minute),
        sig(1*time.Second),
        sig(1*time.Hour),
        sig(1*time.Minute),
    )
    fmt.Printf("done after %v\n", time.Since(start))
}
/*
輸出結果：
done after 1.000182106s
*/

從上述看出，僅僅執行到結果最短的那個，相當於一個“或”操作。程式碼採用了尾遞迴的方式，因為select方式無法預判channel的數量，而迴圈的方式需要處理大量的阻塞問題，不如尾遞迴的方式簡潔。

上述程式碼最後的遞迴中，有一個地方不太理解：程式碼遞迴的過程中為什麼要加入orDone？希望有明白的同學可以解釋一下！