Go Channel：底层结构、并发通信与 select

// hchan 是 channel 在运行时的底层结构体
type hchan struct {
    qcount   uint           // 当前 buf 中已有元素数量
    dataqsiz uint           // buf 容量（环形队列长度）
    buf      unsafe.Pointer // 指向环形队列底层数组
    elemsize uint16         // 单个元素大小（字节）
    closed   uint32         // 是否已关闭，0=未关闭 1=已关闭
    elemtype *_type         // 元素类型信息
    sendx    uint           // 下一次发送写入 buf 的索引（环形）
    recvx    uint           // 下一次接收读取 buf 的索引（环形）
    recvq    waitq          // 等待接收的 goroutine 队列（双向链表）
    sendq    waitq          // 等待发送的 goroutine 队列（双向链表）
    lock     mutex          // 互斥锁，保护 hchan 所有字段
}

package main

import "fmt"

func main() {
    // 步骤1：无缓冲 channel —— 发送和接收必须同时就绪（同步）
    unbuf := make(chan int)
    go func() { unbuf <- 42 }() // 步骤2：发送方阻塞，直到有人接收
    fmt.Println("收到:", <-unbuf) // 步骤3：接收方就绪，双方交接

    // 步骤4：有缓冲 channel —— 缓冲区未满时发送不阻塞（异步）
    buf := make(chan int, 3)
    buf <- 1 // 步骤5：直接放入 buf，不阻塞
    buf <- 2
    buf <- 3
    // buf <- 4 // 步骤6：取消注释会阻塞（缓冲区已满）
    fmt.Println("元素数:", len(buf), "容量:", cap(buf))
}

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string, 2)
    ch <- "hello" // 步骤1：buf 有空位，直接写入不阻塞
    ch <- "world"
    go func() { // 步骤2：第三次发送阻塞（buf 满，加入 sendq）
        ch <- "third"
        fmt.Println("third 发送成功")
    }()
    time.Sleep(100 * time.Millisecond)
    fmt.Println("取出:", <-ch) // 步骤3：取走一个，sendq 中的 g 被唤醒
    time.Sleep(100 * time.Millisecond)
}

package main

import "fmt"

func main() {
    ch := make(chan int) // 无缓冲 channel
    go func() { ch <- 100 }() // 步骤1：发送方先到，加入 sendq 阻塞等待
    fmt.Println("收到:", <-ch) // 步骤2：接收方就绪，直接从发送者拷贝数据

    close(ch)
    val2, ok := <-ch // 步骤3：buf 空 + 已关闭，返回零值 + false
    fmt.Println("关闭后:", val2, ok) // 输出: 0 false
}

package main

import "fmt"

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
    close(ch) // 步骤1：关闭后仍可接收，直到 buf 排空
    for v := range ch { // 步骤2：for range 自动检测 close
        fmt.Println("收到:", v) // 输出: 1, 2, 3
    }
    v, ok := <-ch // 步骤3：排空后返回零值 + false
    fmt.Println("排空后:", v, ok) // 输出: 0 false
    // ch <- 999  // panic: send on closed channel
    // close(ch)  // panic: close of closed channel
}

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 1)

    // 方法1：select+default —— 非阻塞发送
    select {
    case ch <- 42:
        fmt.Println("发送成功")
    default:
        fmt.Println("满了，跳过")
    }
    // 方法2：select+time.After —— 超时控制
    slowCh := make(chan int)
    go func() { time.Sleep(2 * time.Second); slowCh <- 99 }()
    select {
    case v := <-slowCh:
        fmt.Println("收到:", v)
    case <-time.After(500 * time.Millisecond):
        fmt.Println("超时，不等了") // 500ms 内没结果就走这里
    }
    // 方法3：buffered channel —— 增大缓冲区延缓阻塞
    bigBuf := make(chan int, 100)
    for i := 0; i < 100; i++ {
        bigBuf <- i // 缓冲区内不阻塞
    }
}

package main

import "fmt"

func main() {
    ch := make(chan int, 3)
    for i := 0; i < 3; i++ {
        ch <- i // 步骤1：填满缓冲区
    }

    // 步骤2：满了用 select+default 丢弃后续数据
    for i := 3; i < 10; i++ {
        select {
        case ch <- i:
            fmt.Println("写入:", i)
        default:
            fmt.Println("丢弃:", i) // 满了就丢
        }
    }

    // 步骤3：推荐 select+default（原子无竞态），不推荐 len() 判断（有竞态）
    ch2 := make(chan int, 2)
    ch2 <- 1
    ch2 <- 2
    select {
    case ch2 <- 3:
        fmt.Println("写入成功")
    default:
        fmt.Println("写入失败：满")
    }
    // if len(ch2) < cap(ch2) { ch2 <- 3 } // 有竞态：判断和写入之间可能被其他 g 修改
}

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1, ch2 := make(chan string), make(chan string)
    go func() { time.Sleep(100 * time.Millisecond); ch1 <- "来自 ch1" }()
    go func() { time.Sleep(200 * time.Millisecond); ch2 <- "来自 ch2" }()

    // 步骤1：select 多路复用，谁先就绪执行谁
    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println(msg)
        case msg := <-ch2:
            fmt.Println(msg)
        }
    }
}

// scase 代表 select 中的一个 case 分支
type scase struct {
    c    *hchan         // 该 case 操作的 channel（nil 表示永不就绪）
    elem unsafe.Pointer // 数据指针
    kind uint16         // CaseRecv / CaseSend / CaseDefault
}

// selectgo 关键步骤：构造 scase 数组 → 生成 pollorder（随机排列）→ 生成 lockorder（按地址排序）
// → 按 lockorder 加锁 → 按 pollorder 遍历找就绪 case → 无就绪则 default 或阻塞

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 1)

    // 关键点1：随机选择 —— 多个 case 就绪时随机挑一个
    select {
    case ch <- 1:
        fmt.Println("发送 1")
    case ch <- 2:
        fmt.Println("发送 2")
    default:
        fmt.Println("都不行")
    }

    // 关键点2：default 非阻塞 —— 有 default 就不阻塞
    select {
    case v := <-ch:
        fmt.Println("收到:", v)
    default:
        fmt.Println("没数据，不等")
    }
    // 关键点3：nil channel 永不就绪
    var nilCh chan int // 未 make 的 nil channel
    select {
    case <-nilCh: // 永远不会被选中
    case <-time.After(50 * time.Millisecond):
        fmt.Println("超时退出") // 走这里
    }
    // 关键点4：所有 case 阻塞且无 default —— select 自身阻塞
    emptyCh := make(chan int)
    go func() { time.Sleep(50 * time.Millisecond); emptyCh <- 777 }()
    select {
    case v := <-emptyCh:
        fmt.Println("收到:", v) // 阻塞直到有数据
    }
}

package main

import "fmt"

func main() {
    // 步骤1：3 个 channel 高频 select
    chs := make([]chan int, 3)
    for i := range chs {
        chs[i] = make(chan int, 100)
        go func(idx int) {
            for j := 0; j < 1000; j++ {
                chs[idx] <- j
            }
            close(chs[idx])
        }(i)
    }
    // 步骤2：消费者用 select 多路复用，关闭后置 nil
    count := 0
    openCount := len(chs)
    for openCount > 0 {
        select {
        case _, ok := <-chs[0]:
            if !ok { chs[0] = nil; openCount-- }
        case _, ok := <-chs[1]:
            if !ok { chs[1] = nil; openCount-- }
        case _, ok := <-chs[2]:
            if !ok { chs[2] = nil; openCount-- }
        }
        count++
    }
    fmt.Println("共处理:", count)
}

package main

import (
    "fmt"
    "time"
)

func worker(done <-chan struct{}) {
    for {
        select {
        case <-done:
            fmt.Println("worker 退出") // 步骤1：收到停止信号
            return
        default:
            fmt.Println("worker 工作中...")
            time.Sleep(200 * time.Millisecond)
        }
    }
}

func main() {
    done := make(chan struct{}) // 步骤2：空结构体不占内存
    go worker(done)
    time.Sleep(1 * time.Second)
    close(done) // 步骤3：close 广播，通知 worker 退出
    time.Sleep(100 * time.Millisecond)
}

package main

import (
    "fmt"
    "time"
)

func slowOperation() <-chan string {
    result := make(chan string)
    go func() { time.Sleep(2 * time.Second); result <- "完成" }()
    return result
}

func main() {
    select {
    case res := <-slowOperation():
        fmt.Println("结果:", res)
    case <-time.After(1 * time.Second):
        fmt.Println("操作超时！") // 步骤1：1 秒内没结果就超时
    }
    // 注意：超时后 goroutine 仍在运行（泄漏），生产环境应配合 context
}

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("worker %d 退出: %v\n", id, ctx.Err()) // 步骤1：ctx.Done() 返回关闭的 channel
            return
        default:
            fmt.Printf("worker %d 工作中\n", id)
            time.Sleep(300 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    for i := 1; i <= 3; i++ {
        go worker(ctx, i) // 步骤2：3 个 worker 共享同一个 ctx
    }
    time.Sleep(1 * time.Second)
    cancel() // 步骤3：所有 worker 同时收到信号
    time.Sleep(100 * time.Millisecond)
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    tasks := make(chan int, 10)
    var wg sync.WaitGroup

    // 步骤1：启动 3 个消费者
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for task := range tasks { // 步骤2：从同一 channel 取任务
                fmt.Printf("worker %d 处理 %d\n", id, task)
                time.Sleep(100 * time.Millisecond)
            }
        }(w)
    }
    // 步骤3：一个生产者放任务，放完关闭
    for i := 1; i <= 10; i++ { tasks <- i }
    close(tasks) // 步骤4：消费者 range 完自动退出
    wg.Wait()
}

package main

import (
    "fmt"
    "sync"
)

// 步骤1：fanIn 把多个 channel 合并成一个
func fanIn(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                out <- v // 步骤2：转发到 out
            }
        }(ch)
    }
    go func() { wg.Wait(); close(out) }() // 步骤3：全部完成后关闭 out
    return out
}
func main() {
    ch1, ch2 := make(chan int), make(chan int)
    go func() {
        defer close(ch1)
        for i := 1; i <= 3; i++ { ch1 <- i * 10 }
    }()
    go func() {
        defer close(ch2)
        for i := 1; i <= 3; i++ { ch2 <- i * 100 }
    }()

    for v := range fanIn(ch1, ch2) { // 步骤4：扇入合并后消费
        fmt.Println("收到:", v)
    }
}

package main

import "fmt"

// 步骤1：阶段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：阶段2 —— 平方加工
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() {
    // 步骤3：像水管一样串联
    for v := range square(generate(1, 2, 3, 4, 5)) {
        fmt.Println("结果:", v) // 输出: 1, 4, 9, 16, 25
    }
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    // 步骤1：两个无缓冲 channel 作为"接力棒"
    oddCh := make(chan struct{})
    evenCh := make(chan struct{})
    maxNum := 10

    // 步骤2：奇数 goroutine
    go func() {
        defer wg.Done()
        for i := 1; i <= maxNum; i += 2 {
            <-evenCh             // 步骤3：等待信号
            fmt.Printf("奇数: %d\n", i)
            oddCh <- struct{}{}  // 步骤4：通知偶数 g
        }
    }()
    // 步骤5：偶数 goroutine
    go func() {
        defer wg.Done()
        for i := 2; i <= maxNum; i += 2 {
            <-oddCh              // 步骤6：等待奇数 g 的信号
            fmt.Printf("偶数: %d\n", i)
            evenCh <- struct{}{} // 步骤7：通知奇数 g
        }
    }()

    evenCh <- struct{}{} // 步骤8：初始信号启动链条
    wg.Wait()
    fmt.Println("交替打印完成")
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(10)

    // 步骤1：每个 goroutine 一个 channel，串成环形链
    chans := make([]chan struct{}, 10)
    for i := range chans {
        chans[i] = make(chan struct{}, 1) // 步骤2：缓冲 1 防死锁
    }

    for i := 0; i < 10; i++ {
        go func(id int) {
            defer wg.Done()
            <-chans[id] // 步骤3：等前一个 goroutine 信号
            fmt.Printf("g%d: %d\n", id, id)
            next := (id + 1) % 10            // 步骤4：环形通知下一个
            chans[next] <- struct{}{}
        }(i)
    }
    chans[0] <- struct{}{} // 步骤5：给第 0 个发初始信号
    wg.Wait()
    fmt.Println("顺序打印完成")
}

package main

func main() {
    ch := make(chan int, 1)
    ch <- 1
    close(ch)
    // ch <- 2   // panic: send on closed channel（关闭后不能发送）
    // close(ch) // panic: close of closed channel（不能重复关闭）
    v := <-ch     // 关闭后仍可接收
    println("收到:", v)
}

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1, ch2 := make(chan int), make(chan int)
    go func() { time.Sleep(100 * time.Millisecond); ch1 <- 1 }()
    go func() { time.Sleep(200 * time.Millisecond); ch2 <- 2 }()

    active1, active2 := ch1, ch2
    for i := 0; i < 2; i++ {
        select {
        case v := <-active1:
            fmt.Println("ch1:", v)
            active1 = nil // 步骤1：置 nil，该 case 永不再被选中
        case v := <-active2:
            fmt.Println("ch2:", v)
            active2 = nil
        }
    }
    // 步骤2：动态启停 select case 的经典技巧
}

package main

import "fmt"

type Data struct{ ID int; Name string }

func main() {
    // 步骤1：传值 —— channel 拷贝整个结构体，修改原变量不影响副本
    valCh := make(chan Data, 1)
    d := Data{ID: 1, Name: "test"}
    valCh <- d
    d.Name = "changed"
    fmt.Println("传值:", (<-valCh).Name) // 输出: test
    // 步骤2：传指针 —— 只拷贝指针，通过指针修改会影响 channel 中的数据
    ptrCh := make(chan *Data, 1)
    d2 := &Data{ID: 2, Name: "hello"}
    ptrCh <- d2
    d2.Name = "world"
    fmt.Println("传指针:", (<-ptrCh).Name) // 输出: world
}

package main

import "fmt"

// 步骤1：chan<- 只发，<-chan 只收 —— 编译期类型安全
func producer(out chan<- int) { out <- 42 }
func consumer(in <-chan int)  { fmt.Println("收到:", <-in) }

func main() {
    ch := make(chan int, 5)
    go func() {
        defer close(ch) // 步骤2：生产完成后关闭
        for i := 1; i <= 5; i++ { ch <- i }
    }()
    for v := range ch { // 步骤3：for range 自动检测 close
        fmt.Println("收到:", v)
    }
    ch2 := make(chan int, 1)
    producer(ch2) // 步骤4：双向 channel 自动转为单向
    consumer(ch2)
}

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go func(ctx context.Context) {
        ticker := time.NewTicker(200 * time.Millisecond)
        defer ticker.Stop()
        for {
            select {
            case <-ctx.Done():
                fmt.Println("goroutine 退出") // 步骤1：收到取消信号
                return
            case t := <-ticker.C:
                fmt.Println("触发:", t.Format("15:04:05"))
            }
        }
    }(ctx)
    time.Sleep(1 * time.Second)
    cancel() // 步骤2：主协程取消，通知 goroutine
    time.Sleep(100 * time.Millisecond)
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    // 方式1：共享内存 + Mutex
    var mu sync.Mutex
    count := 0
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            count++ // 步骤1：加锁后安全修改
            mu.Unlock()
        }()
    }
    wg.Wait()
    fmt.Println("Mutex count:", count)
    // 方式2：Channel 通信
    ch := make(chan int, 10)
    for i := 0; i < 10; i++ {
        go func(id int) { ch <- id }(i) // 步骤2：通过 channel 传递
    }
    total := 0
    for i := 0; i < 10; i++ {
        total += <-ch
    }
    fmt.Println("Channel total:", total)
    // 方式3：Context —— 取消信号传播
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()
    go func() {
        <-ctx.Done() // 步骤3：超时自动取消
        fmt.Println("Context 取消:", ctx.Err())
    }()
    time.Sleep(600 * time.Millisecond)
}

package main

import (
    "fmt"
    "sync"
)

// 步骤1：mutex 适合保护共享状态（缓存、计数器等固定在一处的数据）
type SafeCache struct {
    mu    sync.RWMutex
    store map[string]string
}

func (c *SafeCache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    val, ok := c.store[key] // 读锁，允许多个 g 同时读
    return val, ok
}
func (c *SafeCache) Set(key, val string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.store[key] = val // 写锁，独占访问
}

// 步骤2：channel 适合传递数据所有权（见第4节 fan-out/fan-in/Pipeline 模式）

func main() {
    cache := &SafeCache{store: make(map[string]string)}
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            cache.Set(fmt.Sprintf("k%d", n), fmt.Sprintf("v%d", n))
        }(i)
    }
    wg.Wait()
    fmt.Println("缓存写入完成")
}

package main

import "fmt"

func main() {
    ch := make(chan string) // 步骤1：无缓冲 channel

    // 步骤2：启动一个 goroutine 作为"发送方"
    go func() {
        ch <- "hello from goroutine" // 步骤3：发送，会阻塞直到有人接收
    }()

    msg := <-ch // 步骤4：主 goroutine 接收，双方在此交接
    fmt.Println("收到:", msg)
}

type hchan struct {
    qcount   uint           // 当前 buf 中元素个数（转盘上现有几盘菜）
    dataqsiz uint           // buf 容量（转盘一圈能放几盘）
    buf      unsafe.Pointer // 指向底层环形数组（连续内存）
    elemsize uint16         // 单个元素大小（字节）
    sendx    uint           // 下一个写入位置（环形）
    recvx    uint           // 下一个读取位置（环形）
    // ... 其余字段略
}

package main

import "fmt"

// miniRing 用最简形式模拟 channel 的环形 buf
type miniRing struct {
    buf      []int // 底层连续数组，对应 hchan.buf
    dataqsiz int   // 容量，对应 hchan.dataqsiz
    sendx    int   // 下一个写入位置
    recvx    int   // 下一个读取位置
    qcount   int   // 当前元素个数
}

func newRing(n int) *miniRing {
    return &miniRing{buf: make([]int, n), dataqsiz: n}
}

// send：写入后 sendx 环形推进，满了返回 false
func (r *miniRing) send(v int) bool {
    if r.qcount == r.dataqsiz {
        return false // 缓冲区满
    }
    r.buf[r.sendx] = v
    r.sendx = (r.sendx + 1) % r.dataqsiz // 环形回绕：到末尾回 0
    r.qcount++
    return true
}

// recv：读取后 recvx 环形推进，空了返回 false
func (r *miniRing) recv() (int, bool) {
    if r.qcount == 0 {
        return 0, false // 缓冲区空
    }
    v := r.buf[r.recvx]
    r.recvx = (r.recvx + 1) % r.dataqsiz // 环形回绕
    r.qcount--
    return v, true
}

func main() {
    r := newRing(3)
    r.send(1)
    r.send(2)
    r.send(3)
    fmt.Println(r.recv()) // 1，recvx 推进到 1
    // 关键：取走 1 后，再 send 会写到 buf[0]（环形回绕），而非 buf[3]（越界）
    r.send(4)
    fmt.Println("底层数组:", r.buf) // [4 2 3] —— 4 占据了被读走的位置 0
    fmt.Println(r.recv()) // 2
    fmt.Println(r.recv()) // 3
    fmt.Println(r.recv()) // 4
}

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        for i := 0; i < 3; i++ {
            fmt.Println("worker 工作中:", i)
            time.Sleep(300 * time.Millisecond)
        }
    }()

    // 步骤1：空 select{} 让 main goroutine 永久阻塞
    // 没有 case、没有 default，main 在此一直 park，
    // 把 CPU 让给上面的 worker 运行
    select {}
    // 注意：这行之后永远不会执行
}

// 写法1：空 select（推荐，零 CPU 占用，语义清晰）
select {}

// 写法2：死循环（不推荐，会空转占满一个 CPU 核）
// for {}

// 写法3：等一个永不关闭/永不发送的 channel（等价于永久阻塞）
// done := make(chan struct{})
// <-done

package main

import "fmt"

var c = make(chan int) // 无缓冲
var a int

func f() {
    a = 1   // 步骤1：先写共享变量
    <-c     // 步骤2：在无缓冲 channel 上接收（会阻塞，等发送方）
    // 走到这里时，下面的 c <- 0 已经完成
}

func main() {
    go f()
    c <- 0      // 步骤3：发送，会阻塞直到 f 里的 <-c 就绪
    fmt.Println(a) // 步骤4：输出 1 —— 必然看到 a=1
}

package main

import "fmt"

var a int

func f() {
    a = 1 // 没有任何同步原语保护
}

func main() {
    go f()
    fmt.Println(a) // 可能输出 0（f 还没来得及写），也可能 1 —— 数据竞态
}

package main

import "fmt"

func main() {
    ch := make(chan int, 1) // 缓冲 1
    ch <- 1                 // 发送不阻塞（缓冲有空位）
    // 此时发送已完成，但还没有接收者——
    // 缓冲 channel 的 happens-before 只在"缓冲区满、被迫同步"时才建立
    fmt.Println(<-ch) // 接收，看到 1
}

package main

import (
    "fmt"
    "time"
)

func main() {
    var ch chan int // 步骤1：声明但没 make —— 这是 nil channel

    // 步骤2：在 select 中 nil channel 永远不被选中（永不就绪）
    select {
    case v, ok := <-ch:
        fmt.Println("收到:", v, ok) // 永远不会走这里
    case <-time.After(100 * time.Millisecond):
        fmt.Println("超时，nil channel 未被选中") // 走这里
    }

    // 步骤3：直观验证——nil channel 收发都永久阻塞（不放主 goroutine，否则死锁）
    done := make(chan struct{})
    go func() {
        // ch <- 1 // 取消注释：永久阻塞，goroutine 泄漏
        close(done)
    }()
    <-done
}

package main

func main() {
    // 情形1：close 一个只接收方向的 channel —— 编译期错误
    // var recv <-chan int = make(<-chan int)
    // close(recv) // 编译报错：cannot close receive-only channel

    // 情形2：close nil channel —— panic
    var nilCh chan int
    // close(nilCh) // panic: close of nil channel

    // 情形3：重复 close —— panic
    ch := make(chan int, 1)
    ch <- 1
    close(ch)
    // close(ch) // panic: close of closed channel
    _ = nilCh
}

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan int)
    go func() { time.Sleep(100 * time.Millisecond); ch1 <- 1 }()

    var active chan int = ch1
    for i := 0; i < 1; i++ {
        select {
        case v := <-active:
            fmt.Println("收到:", v)
            active = nil // 步骤1：置 nil 后该 case 永远不被选中（动态禁用）
        }
    }
}

package main

import "fmt"

// 步骤1：外层 channel 的元素类型，是另一个 channel
// service 收到一个"回复通道"，把结果写回它
func service(req chan chan int) {
    reply := make(chan int, 1)
    reply <- 42       // 步骤2：往回复通道写结果
    req <- reply      // 步骤3：把回复通道作为"数据"传给调用方
}

func main() {
    // 步骤4：chan chan int —— 元素本身是个 chan int
    box := make(chan chan int, 1)
    go service(box)

    replyCh := <-box       // 步骤5：取出内层回复通道
    fmt.Println(<-replyCh) // 步骤6：从回复通道读结果，输出 42
}

package main

import "fmt"

// 步骤1：入参是"只接收方向 channel 的发送端"——
// 调用方只能往里塞一个只收 channel，类型系统保证安全
func deliver(out chan<- <-chan int) {
    inner := make(chan int, 1)
    inner <- 7
    out <- inner // 步骤2：把只收 channel 传出
}

func main() {
    box := make(chan (<-chan int), 1)
    deliver(box)
    r := <-box
    fmt.Println(<-r) // 输出 7
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// Task 是队列中传递的消息
type Task struct {
	ID   int
	From string
}

func main() {
	// 步骤1：带缓冲的 channel 充当消息队列（缓冲削峰，生产者无需等消费者就绪）
	queue := make(chan Task, 10)

	var producerWG, consumerWG sync.WaitGroup

	// 步骤2：启动 3 个生产者（多生产者 = 扇入 fan-in 到同一个队列）
	producerCount := 3
	for p := 1; p <= producerCount; p++ {
		producerWG.Add(1)
		go func(pid int) {
			defer producerWG.Done()
			for i := 1; i <= 5; i++ {
				task := Task{ID: (pid-1)*5 + i, From: fmt.Sprintf("P%d", pid)}
				queue <- task // 缓冲没满就直接入队，满了才阻塞等待消费者取走
				fmt.Printf("生产者 P%d 投递任务 %d\n", pid, task.ID)
				time.Sleep(20 * time.Millisecond)
			}
		}(p)
	}

	// 步骤3：启动 2 个消费者（多消费者 = 扇出 fan-out 从同一个队列取）
	consumerCount := 2
	for c := 1; c <= consumerCount; c++ {
		consumerWG.Add(1)
		go func(cid int) {
			defer consumerWG.Done()
			// 步骤4：用 for range 持续消费，channel 被 close 后自动退出（close 广播）
			for task := range queue {
				fmt.Printf("消费者 C%d 处理任务 %d (来自 %s)\n", cid, task.ID, task.From)
				time.Sleep(30 * time.Millisecond)
			}
			fmt.Printf("消费者 C%d 收到关闭信号，退出\n", cid)
		}(c)
	}

	// 步骤5：等所有生产者投递完毕，再 close 队列——这是“关闭广播退出”的关键
	//        close 后所有 for range 的消费者会立即收到信号并退出
	producerWG.Wait()
	close(queue)

	// 步骤6：等所有消费者处理完剩余任务并退出
	consumerWG.Wait()
	fmt.Println("所有任务处理完成，消息队列关闭")
}