producer 計算三個平方，消費者只取第一個。剩下的 send 會怎樣？

package main

import (
    "fmt"
    "time"
)

func squares() (<-chan int, <-chan struct{}) {
    out := make(chan int)
    done := make(chan struct{})
    go func() {
        defer close(done)
        defer close(out)
        for _, n := range []int{1, 2, 3} {
            out <- n * n
        }
    }()
    return out, done
}

func main() {
    values, done := squares()
    fmt.Println(<-values)
    select {
    case <-done:
        fmt.Println("stopped")
    case <-time.After(50 * time.Millisecond):
        fmt.Println("still blocked")
    }
}

儲存為 main.go，執行 go run main.go。Go 1.27.0 的輸出：

1
still blocked

卡在第二次 send

無緩衝的 out 需要接收方。第一個值交出後，沒有人接第二個值；producer 無法返回，兩個 defer 也尚未執行。

50 ms 只讓範例顯示結果，並沒有修復阻塞。這個短程式會隨 main 結束；若相同模式用在持續運行的服務中，工作就會一直留著。

加一格 buffer 就能取消工作。 它只能暫存一個值，第三次 send 仍會阻塞。

可以取消的管線 加入取消訊號，並等待 producer 收尾。兩份程式的差別在 send 的出口。

消費者只需要第一個平方。取到後，它通知 producer 停止，並等待收尾。

package main

import (
    "context"
    "fmt"
)

func squares(ctx context.Context) (<-chan int, <-chan struct{}) {
    out := make(chan int)
    done := make(chan struct{})
    go func() {
        defer close(done)
        defer close(out)
        for _, n := range []int{1, 2, 3} {
            select {
            case out <- n * n:
            case <-ctx.Done():
                return
            }
        }
    }()
    return out, done
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    values, done := squares(ctx)
    fmt.Println(<-values)
    cancel()
    <-done
    fmt.Println("stopped")
}

儲存為 main.go，執行 go run main.go。Go 1.27.0 的輸出：

1
stopped

兩個訊號，各管一件事

ctx.Done() 通知 producer 取消；done 關閉則表示 producer 已完成收尾。cancel() 本身不等待工作結束。

消費者不再接收時，send 無法繼續。取消訊號讓 select 走到 return，接著執行 defer：先關閉 out，再關閉 done。

誰關閉 channel

producer 是 out 的唯一發送者，由它關閉最容易確認不會再有 send。消費者直接關閉 out，反而可能讓 producer 向已關閉的 channel 發送而 panic。 ^owner

這個模式只涵蓋 channel 等待；計算或 I/O 也必須提供自己的取消方式。¹