面试官：channel关闭后还能读吗？我答完直接挂了

// 无缓冲：发送会阻塞，直到有人接收
ch := make(chan int)
go func() {
    ch <- 1  // 阻塞！等待接收方
}()
<-ch  // 接收后，发送方才能继续

// 有缓冲：缓冲区未满时不阻塞
ch := make(chan int, 3)
ch <- 1  // 不阻塞，直接写入缓冲区
ch <- 2  
ch <- 3  
ch <- 4  // 满了！这里才开始阻塞

ch := make(chan int, 2)
ch <- 100
ch <- 200
close(ch)

// 还能读！缓冲区数据不会被清空
v1, ok1 := <-ch  // v1=100, ok1=true ✓ 还有数据
v2, ok2 := <-ch  // v2=200, ok2=true ✓ 还有数据  
v3, ok3 := <-ch  // v3=0, ok3=false  ✓ 已关闭且无数据

// 这时候再写就完了
ch <- 300  // ❌ panic! send on closed channel

var ch chan int  // nil channel

<-ch      // 永久阻塞！
ch <- 1   // 永久阻塞！
close(ch) // panic: close of nil channel

// ❌ 错误：nil和关闭是两回事
if ch == nil {
    // 这判断的是channel是否为nil，不是是否关闭
}

// ✅ 方法1：comma ok（最常用）
val, ok := <-ch
if !ok {
    // ok为false表示channel已关闭且无数据可读
    fmt.Println("channel已关闭")
}

// ✅ 方法2：配合select实现非阻塞检查
select {
case val, ok := <-ch:
    if !ok {
        fmt.Println("channel已关闭")
    } else {
        fmt.Println("读到数据:", val)
    }
default:
    // 说明当前channel既无数据可读，也未关闭（仍在等待中）
    fmt.Println("channel暂无数据")
}

ch := make(chan string)

go func() {
    time.Sleep(2 * time.Second)
    ch <- "result"
}()

select {
case result := <-ch:
    fmt.Println("收到:", result)
case <-time.After(1 * time.Second):
    // 超时处理
    fmt.Println("超时了，不等了")
}

select {
case v1 := <-ch1:
    handleCh1(v1)
case v2 := <-ch2:
    handleCh2(v2)
case <-done:
    fmt.Println("收到退出信号")
    return
}

// ❌ 错误：在循环里使用time.After会导致timer堆积
for {
    select {
    case msg := <-ch:
        process(msg)
    case <-time.After(1 * time.Second):  // 每次循环都创建新timer！
        log.Println("超时")
    }
}

// ✅ 正确：使用time.NewTimer并复用
timer := time.NewTimer(1 * time.Second)
defer timer.Stop()

for {
    timer.Reset(1 * time.Second)  // 重置复用
    select {
    case msg := <-ch:
        process(msg)
    case <-timer.C:
        log.Println("超时")
    }
}

// 或者使用context.WithTimeout
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()

select {
case msg := <-ch:
    process(msg)
case <-ctx.Done():
    log.Println("超时")
}

// runtime/hchan.go（简化版）
type hchan struct {
    qcount   uint           // 当前缓冲区元素个数
    dataqsiz uint           // 缓冲区容量
    buf      unsafe.Pointer // 指向环形缓冲区的指针
    sendx    uint           // 发送索引（写位置）
    recvx    uint           // 接收索引（读位置）
    recvq    waitq          // 等待接收的goroutine队列（sudog双向链表）
    sendq    waitq          // 等待发送的goroutine队列（sudog双向链表）
    lock     mutex          // 互斥锁，保证线程安全
}

jobs := make(chan int, 100)
results := make(chan int, 100)

// worker函数 - 使用单向channel增加类型安全
// jobs只读，results只写，防止在worker里误操作
func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d 处理任务 %d\n", id, j)
        time.Sleep(time.Second) // 模拟处理
        results <- j * 2
    }
}

// 启动3个worker
for w := 1; w <= 3; w++ {
    go worker(w, jobs, results)
}

// 投递9个任务
for j := 1; j <= 9; j++ {
    jobs <- j
}
close(jobs)

// 收集结果
for a := 1; a <= 9; a++ {
    <-results
}

// 修正版：添加jobs参数，保证代码逻辑自洽
func worker(jobCh <-chan int, stopCh <-chan struct{}) {
    for {
        select {
        case job := <-jobCh:
            process(job)
        case <-stopCh:
            fmt.Println("收到退出信号，正在清理资源...")
            // 保存状态、关闭连接等
            return
        }
    }
}

// main函数里
jobCh := make(chan int)
stopCh := make(chan struct{})

// 启动worker
go worker(jobCh, stopCh)

// 投递任务...
jobCh <- 1

// 收到退出信号时
close(stopCh)  // 广播退出信号给所有worker

// 每秒产生10个令牌
rate := 10
bucket := make(chan struct{}, rate)

// 定时填充令牌
go func() {
    ticker := time.NewTicker(time.Second / time.Duration(rate))
    defer ticker.Stop()
    for range ticker.C {
        select {
        case bucket <- struct{}{}:  // 放入令牌
        default:  // 桶满了就丢弃，不阻塞
        }
    }
}()

// 处理请求时先取令牌
func handleRequest() {
    <-bucket  // 拿到令牌才能继续，没令牌就阻塞等待
    // 处理请求...
}

// ✅ 正确：发送方关闭
func sender(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)  // 发送完关闭
}

// ❌ 错误：接收方关闭
func receiver(ch <-chan int) {
    for v := range ch {
        fmt.Println(v)
    }
    close(ch)  // 千万别这么做！
}