Go 并发原语 - Channel

// 声明
var ch chan int          // 双向 channel
var sendCh chan<- int    // 只发送
var recvCh <-chan int    // 只接收

// 初始化（必须用 make）
ch = make(chan int)      // 无缓冲
ch = make(chan int, 10)  // 有缓冲，容量 10

// 方式 1：comma-ok 模式
v, ok := <-ch
if !ok {
    // channel 已关闭
}

// 方式 2：for range（channel 关闭时自动退出循环）
for v := range ch {
    fmt.Println(v)
}
// 到这里说明 ch 已关闭

select {
case v := <-ch1:
    fmt.Println("从 ch1 收到:", v)
case v := <-ch2:
    fmt.Println("从 ch2 收到:", v)
case ch3 <- 42:
    fmt.Println("向 ch3 发送成功")
default:
    fmt.Println("没有 channel 就绪")
}

select {
case v := <-ch:
    fmt.Println("收到:", v)
case <-time.After(3 * time.Second):
    fmt.Println("超时")
}

cases := make([]reflect.SelectCase, len(channels))
for i, ch := range channels {
    cases[i] = reflect.SelectCase{
        Dir:  reflect.SelectRecv,
        Chan: reflect.ValueOf(ch),
    }
}

chosen, value, ok := reflect.Select(cases)
fmt.Printf("从 channel %d 收到: %v (ok=%v)\n", chosen, value, ok)

func main() {
    quit := make(chan struct{})

    for i := 0; i < 5; i++ {
        go func(id int) {
            <-quit // 阻塞等待
            fmt.Printf("Worker %d: 收到退出信号\n", id)
        }(i)
    }

    time.Sleep(time.Second)
    close(quit) // ✅ 一次 close 通知所有 worker
    time.Sleep(time.Second)
}

// 阶段 1：生成数据
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            out <- n
        }
    }()
    return out
}

// 阶段 2：过滤偶数
func filterEven(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            if n%2 == 0 {
                out <- n
            }
        }
    }()
    return out
}

// 阶段 3：平方
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            out <- n * n
        }
    }()
    return out
}

func main() {
    // 组装流水线
    ch := generate(1, 2, 3, 4, 5, 6, 7, 8)
    ch = filterEven(ch)
    ch = square(ch)

    for v := range ch {
        fmt.Println(v) // 4, 16, 36, 64
    }
}

func fanIn(channels ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    merged := make(chan int)

    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                merged <- v
            }
        }(ch)
    }

    go func() {
        wg.Wait()
        close(merged)
    }()
    return merged
}

var sem = make(chan struct{}, 10) // 最多 10 个并发

func doWork(id int) {
    sem <- struct{}{}        // 获取信号量（缓冲满了就阻塞）
    defer func() { <-sem }() // 释放信号量

    fmt.Printf("Worker %d: 开始\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d: 完成\n", id)
}

func orDone(channels ...<-chan struct{}) <-chan struct{} {
    done := make(chan struct{})
    go func() {
        defer close(done)
        cases := make([]reflect.SelectCase, len(channels))
        for i, ch := range channels {
            cases[i] = reflect.SelectCase{
                Dir:  reflect.SelectRecv,
                Chan: reflect.ValueOf(ch),
            }
        }
        reflect.Select(cases) // 任意一个就绪就返回
    }()
    return done
}

ch := make(chan int)
close(ch)
ch <- 1 // panic: send on closed channel 💀

// ❌ goroutine 泄漏
func leaky() <-chan int {
    ch := make(chan int)
    go func() {
        val := longComputation()
        ch <- val // 如果没人接收，这个 goroutine 永远阻塞 💀
    }()
    return ch
}

// ✅ 用 context 控制
func safe(ctx context.Context) <-chan int {
    ch := make(chan int)
    go func() {
        val := longComputation()
        select {
        case ch <- val:
        case <-ctx.Done(): // 被取消时退出
        }
    }()
    return ch
}

var ch chan int // nil channel
ch <- 1        // 永久阻塞，不是 panic！
<-ch           // 永久阻塞，不是 panic！

ch1 = nil // select 中 ch1 的 case 再也不会被选中

// ❌ 忘记 close，for range 永远不会结束
ch := make(chan int)
go func() {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    // 忘记 close(ch) 💀
}()

for v := range ch {
    fmt.Println(v) // 打印 0-4 后永久阻塞
}

# 两个应该加入 CI 的命令
go vet ./...
go test -race ./...