ch := make(chan int)      // 無緩沖通道
ch := make(chan int, 5)   // 緩沖通道，容量為5

func producer(ch chan<- int) {  // 只能發(fā)送
    ch <- 42
}
func consumer(ch <-chan int) {  // 只能接收
    v := <-ch
}

select {
case msg := <-ch1:
    fmt.Println("收到 ch1:", msg)
case ch2 <- 42:
    fmt.Println("發(fā)送到 ch2")
case <-time.After(3 * time.Second):
    fmt.Println("超時(shí)了")
default:
    fmt.Println("所有通道都沒準(zhǔn)備好，立刻返回")
}

select {
case result := <-ch:
    return result
case <-time.After(5 * time.Second):
    return errors.New("超時(shí)")
}

for v := range ch {
    fmt.Println(v)
}
// 等價(jià)于：
for {
    v, ok := <-ch
    if !ok { break }  // 通道已關(guān)閉
    fmt.Println(v)
}

// ? 正確：發(fā)送方關(guān)閉
func sender(ch chan int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)  // 發(fā)送方關(guān)閉
}
// ? 錯(cuò)誤：接收方關(guān)閉
func receiver(ch chan int) {
    v := <-ch
    close(ch)  // 危險(xiǎn)！可能還有其他發(fā)送方
}
// ? 錯(cuò)誤：重復(fù)關(guān)閉
close(ch)
close(ch)  // panic: close of closed channel

var sendOnly chan<- int = ch     // ? 編譯通過
var recvOnly <-chan int = ch     // ? 編譯通過
var both chan int = sendOnly      // ? 編譯失敗

// ? 泄漏：發(fā)送方退出后，接收方還在阻塞
func leak() {
    ch := make(chan int)
    go func() {
        for v := range ch {  // 永遠(yuǎn)等下去
            fmt.Println(v)
        }
    }()
    // 沒有 close，也沒有發(fā)送，goroutine 永遠(yuǎn)不退出
}

// ? 死鎖：兩個(gè) goroutine 互相等對方
ch := make(chan int)
go func() { ch <- 1 }()     // 阻塞：沒人接收
<-ch                         // 阻塞：沒人發(fā)送
// fatal error: all goroutines are asleep - deadlock!

var ch chan int  // nil 通道，不是空通道！
ch <- 1          // 永久阻塞，不會 panic

ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
ch <- 4  // 阻塞！容量已滿

select {
case ch <- 1:  // 如果 ch 滿了且沒人收，這里永久阻塞
}
// 沒有 default，沒有超時(shí)，沒有其他 case → 死鎖

func workerPool(jobs <-chan int, results chan<- int, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

// Fan-Out：一個(gè)入口，多個(gè) worker 并行處理
func fanOut(input <-chan int) []<-chan int {
    outs := make([]<-chan int, 3)
    for i := range outs {
        ch := make(chan int)
        outs[i] = ch
        go func(out chan<- int) {
            for v := range input {
                out <- heavyWork(v)
            }
            close(out)
        }(ch)
    }
    return outs
}
// Fan-In：多個(gè)入口，匯聚到一個(gè)出口
func fanIn(ins ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, in := range ins {
        wg.Add(1)
        go func(ch <-chan int) {
            defer wg.Done()
            for v := range ch {
                out <- v
            }
        }(in)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

func pipeline(input <-chan int) <-chan int {
    // Stage 1: 過濾
    filtered := filter(input, func(x int) bool { return x%2 == 0 })
    // Stage 2: 映射
    mapped := mapFunc(filtered, func(x int) int { return x * 2 })
    return mapped
}

func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job, ok := <-jobs:
            if !ok { return }
            process(job)
        case <-ctx.Done():  // 收到取消信號，立即退出
            fmt.Println("worker 退出:", ctx.Err())
            return
        }
    }
}