Channel操作 #

ch := make(chan int)
ch <- 42

func main() {
    ch := make(chan int)
    
    go func() {
        time.Sleep(time.Second)
        <-ch  // 接收
    }()
    
    ch <- 1  // 阻塞直到被接收
    fmt.Println("Sent")
}

ch := make(chan int, 2)

ch <- 1  // 不阻塞
ch <- 2  // 不阻塞
// ch <- 3  // 阻塞

v := <-ch

v, ok := <-ch
if !ok {
    fmt.Println("Channel closed")
}

func main() {
    ch := make(chan int)
    
    go func() {
        time.Sleep(time.Second)
        ch <- 1
    }()
    
    v := <-ch  // 阻塞直到有数据
    fmt.Println(v)
}

select {
case v := <-ch:
    fmt.Println(v)
default:
    fmt.Println("No data")
}

ch := make(chan int)
close(ch)

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

fmt.Println(<-ch)  // 1
fmt.Println(<-ch)  // 2
fmt.Println(<-ch)  // 0（零值）

for {
    v, ok := <-ch
    if !ok {
        break
    }
    fmt.Println(v)
}

for v := range ch {
    fmt.Println(v)
}

ch := make(chan int, 3)

fmt.Println(cap(ch))  // 3
fmt.Println(len(ch))  // 0

ch <- 1
fmt.Println(len(ch))  // 1

func isFull(ch chan int) bool {
    return len(ch) == cap(ch)
}

func isEmpty(ch chan int) bool {
    return len(ch) == 0
}

func batchProcess(ch chan int, batchSize int) []int {
    batch := make([]int, 0, batchSize)
    for i := 0; i < batchSize; i++ {
        select {
        case v := <-ch:
            batch = append(batch, v)
        default:
            return batch
        }
    }
    return batch
}

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)
    }
}

type Queue struct {
    ch chan int
}

func (q *Queue) Send() chan<- int {
    return q.ch
}

func (q *Queue) Receive() <-chan int {
    return q.ch
}

func rateLimiter(limit int) chan struct{} {
    ch := make(chan struct{}, limit)
    for i := 0; i < limit; i++ {
        ch <- struct{}{}
    }
    return ch
}

func main() {
    limiter := rateLimiter(10)
    
    for i := 0; i < 100; i++ {
        <-limiter  // 获取令牌
        go func() {
            defer func() { limiter <- struct{}{} }()  // 归还令牌
            // 处理请求
        }()
    }
}

func withTimeout(ch <-chan int, timeout time.Duration) (int, error) {
    select {
    case v := <-ch:
        return v, nil
    case <-time.After(timeout):
        return 0, errors.New("timeout")
    }
}

func broadcast(msg string, subscribers []chan string) {
    for _, ch := range subscribers {
        select {
        case ch <- msg:
        default:
        }
    }
}

func pipeline() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    go func() {
        for i := 0; i < 10; i++ {
            ch1 <- i
        }
        close(ch1)
    }()
    
    go func() {
        for v := range ch1 {
            ch2 <- v * 2
        }
        close(ch2)
    }()
    
    for v := range ch2 {
        fmt.Println(v)
    }
}

func worker(done chan struct{}) {
    defer close(done)
    // 工作
}

func main() {
    done := make(chan struct{})
    go worker(done)
    <-done
}

func compute(n int, results chan<- int) {
    results <- n * n
}

func main() {
    results := make(chan int, 10)
    
    for i := 0; i < 10; i++ {
        go compute(i, results)
    }
    
    for i := 0; i < 10; i++ {
        fmt.Println(<-results)
    }
}

func worker(cancel <-chan struct{}) {
    for {
        select {
        case <-cancel:
            return
        default:
            // 工作
        }
    }
}

func safeSend(ch chan int, v int) error {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()
    ch <- v
    return nil
}

func safeClose(ch chan int) {
    select {
    case <-ch:
        // 已关闭
    default:
        close(ch)
    }
}

func producer(ch chan int) {
    defer close(ch)  // 生产者关闭
    // ...
}

select {
case ch <- v:
    // 发送成功
default:
    // 处理缓冲满
}

ch := make(chan int, runtime.NumCPU()*10)