Go channel 与 select：阻塞语义、关闭规则与工程实践

var ch chan int          // nil channel，零值
ch = make(chan int)      // 无缓冲（容量 0）
ch2 := make(chan int, 0) // 同样无缓冲
buf := make(chan int, 8) // 缓冲容量 8

// 无缓冲：必须另一端参与
ch := make(chan string)
go func() { ch <- "ready" }()
msg := <-ch

// 有缓冲：容量内发送不阻塞
b := make(chan int, 2)
b <- 1
b <- 2
// b <- 3 // 若无接收方，此处阻塞

out := make(chan int, 3)
out <- 1
out <- 2
close(out)

for v := range out { // 自动在关闭且排空后结束
    fmt.Println(v)
}
v, ok := <-out
fmt.Println(v, ok) // 0 false

select {
case v := <-a:
    handleA(v)
case b <- x:
    // 发送成功
case <-time.After(200 * time.Millisecond):
    // 超时分支（timer channel）
default:
    // 非阻塞探测：此刻无人可通信
}

select {
case ch <- job:
default:
    // 队列满或无接收方：降级、丢弃或写指标
}

sem := make(chan struct{}, MaxOutstanding)

func handle(r *Request) {
    sem <- struct{}{}        // 占坑；满则阻塞
    defer func() { <-sem }() // 释放
    process(r)
}

select {
case res := <-resultCh:
    return res, nil
case <-ctx.Done():
    return nil, ctx.Err()
}

package main

import (
    "fmt"
    "time"
)

func mustPanic(name string, fn func()) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println(name, "panic OK:", r)
        } else {
            fmt.Println(name, "ERROR: expected panic")
        }
    }()
    fn()
}

func main() {
    // 1) 无缓冲：单 goroutine 发送会死锁（用超时模拟探测）
    ub := make(chan int)
    go func() {
        select {
        case ub <- 1:
            fmt.Println("unexpected send success")
        case <-time.After(50 * time.Millisecond):
            fmt.Println("unbuffered send blocked as expected")
        }
    }()
    time.Sleep(80 * time.Millisecond)

    // 2) 有缓冲：容量内不阻塞
    b := make(chan int, 1)
    b <- 42
    fmt.Println("buffered len/cap:", len(b), cap(b))

    // 3) 关闭后接收
    close(b)
    v, ok := <-b
    fmt.Println("drain closed:", v, ok) // 42 true
    v, ok = <-b
    fmt.Println("after empty:", v, ok) // 0 false

    // 4) 向关闭通道发送 → panic
    mustPanic("send-on-closed", func() { b <- 1 })

    // 5) close(nil) → panic
    var n chan int
    mustPanic("close-nil", func() { close(n) })

    // 6) select 伪随机：两个都就绪时多次运行会看到不同分支
    a1, a2 := make(chan int, 1), make(chan int, 1)
    a1 <- 1
    a2 <- 2
    counts := map[string]int{}
    for i := 0; i < 200; i++ {
        // 重新填满，保证两 case 均可推进
        select {
        case <-a1:
            counts["a1"]++
            a1 <- 1
        case <-a2:
            counts["a2"]++
            a2 <- 2
        }
    }
    fmt.Println("select distribution:", counts)

    // 7) 仅 nil + 无 default：用超时包裹，避免真死锁进程
    var nilCh chan int
    select {
    case <-nilCh:
        fmt.Println("unreachable")
    case <-time.After(50 * time.Millisecond):
        fmt.Println("nil-only select would block forever without timeout")
    }
}

func gen(done <-chan struct{}, nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            select {
            case out <- n:
            case <-done:
                return
            }
        }
    }()
    return out
}

// main 中：
done := make(chan struct{})
defer close(done) // 退出时广播取消
for n := range sq(done, gen(done, 2, 3)) {
    fmt.Println(n)
    break // 提前结束也安全：done 关闭后上游不再堵在发送上
}