type hchan struct {
    qcount   uint           // 当前队列中的元素数量
    dataqsiz uint           // 循环队列的大小（容量）
    buf      unsafe.Pointer // 指向大小为dataqsiz的循环队列
    elemsize uint16         // 元素类型大小
    closed   uint32         // 非零表示channel已关闭
    elemtype *_type         // 元素类型
    sendx    uint           // 发送操作的索引位置
    recvx    uint           // 接收操作的索引位置
    recvq    waitq          // 接收者等待队列（阻塞在接收操作的goroutine）
    sendq    waitq          // 发送者等待队列（阻塞在发送操作的goroutine）
    lock     mutex          // 互斥锁，保护hchan中的所有字段
}

func makechan(t *chantype, size int) *hchan {
    elem := t.elem
    
    // 计算并检查内存需求
    mem, overflow := math.MulUintptr(elem.size, uintptr(size))
    if overflow || mem > maxAlloc-hchanSize || size < 0 {
        panic(plainError("makechan: size out of range"))
    }
    
    var c *hchan
    switch {
    case mem == 0:
        // 队列大小为零（无缓冲channel）
        c = (*hchan)(mallocgc(hchanSize, nil, true))
        c.buf = c.raceaddr()
    case elem.ptrdata == 0:
        // 元素不包含指针时的优化分配
        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
        c.buf = add(unsafe.Pointer(c), hchanSize)
    default:
        // 元素包含指针的标准分配
        c = new(hchan)
        c.buf = mallocgc(mem, elem, true)
    }
    
    c.elemsize = uint16(elem.size)
    c.elemtype = elem
    c.dataqsiz = uint(size)
    
    return c
}

func main() {
    // 创建缓冲区大小为3的channel
    ch := make(chan int, 3)
    
    // 启动多个发送者
    for i := 0; i < 5; i++ {
        go func(val int) {
            ch <- val
            fmt.Printf("发送: %d\n", val)
        }(i)
    }
    
    // 启动多个接收者
    for i := 0; i < 5; i++ {
        go func() {
            val := <-ch
            fmt.Printf("接收: %d\n", val)
        }()
    }
    
    // 等待所有goroutine完成
    time.Sleep(time.Second)
}

select {
case data := <-ch1:
    // 处理来自ch1的数据
case ch2 <- value:
    // 数据成功发送到ch2
case <-time.After(timeout):
    // 超时处理
default:
    // 所有channel操作都会阻塞时执行
}

type RateLimiter struct {
    tokens chan struct{}
}

func NewRateLimiter(rate int) *RateLimiter {
    rl := &RateLimiter{
        tokens: make(chan struct{}, rate),
    }
    
    // 初始填充令牌
    for i := 0; i < rate; i++ {
        rl.tokens <- struct{}{}
    }
    
    // 按固定速率补充令牌
    go func() {
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()
        
        for range ticker.C {
            select {
            case rl.tokens <- struct{}{}:
                // 添加令牌成功
            default:
                // 令牌桶已满
            }
        }
    }()
    
    return rl
}

func (rl *RateLimiter) Allow() bool {
    select {
    case <-rl.tokens:
        return true
    default:
        return false
    }
}

func worker(id int, jobs <-chan Job, results chan<- Result) {
    for job := range jobs {
        result := process(job)
        results <- result
    }
}

func main() {
    const numJobs = 100
    const numWorkers = 10
    
    jobs := make(chan Job, numJobs)
    results := make(chan Result, numJobs)
    
    // 启动工作者
    for w := 1; w <= numWorkers; w++ {
        go worker(w, jobs, results)
    }
    
    // 发送工作
    for j := 1; j <= numJobs; j++ {
        jobs <- Job{ID: j}
    }
    close(jobs)
    
    // 收集结果
    for a := 1; a <= numJobs; a++ {
        <-results
    }
}