Go语言Channel中缓冲与无缓冲的区别与应用

ch := make(chan int) // 创建一个传递int类型的Channel

ch <- 42   // 将42发送到Channel
v := <-ch  // 从Channel接收值并赋给v

ch := make(chan int) // 无缓冲Channel

func worker(done chan bool) {
    fmt.Println("working...")
    time.Sleep(time.Second)
    fmt.Println("done")
    done <- true
}

func main() {
    done := make(chan bool)
    go worker(done)
    <-done  // 阻塞直到worker完成
}

ch := make(chan int, 3) // 缓冲区大小为3的Channel

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
}

func main() {
    ch := make(chan int)
    ch <- 42  // 阻塞，没有接收者
    fmt.Println(<-ch)
}

func main() {
    ch := make(chan int, 1)
    ch <- 1
    ch <- 2  // 阻塞，缓冲区已满
    fmt.Println(<-ch)
}

select {
case v := <-ch1:
    fmt.Println("received", v)
case ch2 <- 42:
    fmt.Println("sent 42")
default:
    fmt.Println("no communication")
}

select {
case ch <- data:
    // 发送成功
default:
    // 缓冲区满，执行其他操作
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "processing job", j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    
    // 启动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
    }
}

func main() {
    burstyLimiter := make(chan time.Time, 3)
    
    // 预先填充缓冲区，允许突发请求
    for i := 0; i < 3; i++ {
        burstyLimiter <- time.Now()
    }
    
    // 每200ms添加一个新令牌
    go func() {
        for t := range time.Tick(200 * time.Millisecond) {
            burstyLimiter <- t
        }
    }()
    
    // 模拟5个请求
    for i := 1; i <= 5; i++ {
        <-burstyLimiter
        fmt.Println("request", i, time.Now())
    }
}

func main() {
    dataChan := make(chan int, 10)      // 缓冲Channel用于数据传输
    doneChan := make(chan struct{})    // 无缓冲Channel用于同步
    
    // 生产者
    go func() {
        defer close(dataChan)
        for i := 0; i < 10; i++ {
            dataChan <- i
        }
    }()
    
    // 消费者
    go func() {
        for d := range dataChan {
            fmt.Println(d)
        }
        close(doneChan)
    }()
    
    <-doneChan  // 等待消费者完成
}

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()

select {
case <-ch:
    // 正常接收
case <-ctx.Done():
    // 超时处理
}

v, ok := <-ch
if !ok {
    // Channel已关闭
}

func benchmarkChannel(b *testing.B, bufferSize int) {
    ch := make(chan int, bufferSize)
    go func() {
        for i := 0; i < b.N; i++ {
            ch <- i
        }
        close(ch)
    }()
    for range ch {
    }
}

func BenchmarkUnbuffered(b *testing.B) { benchmarkChannel(b, 0) }
func BenchmarkBuffer1(b *testing.B)    { benchmarkChannel(b, 1) }
func BenchmarkBuffer10(b *testing.B)   { benchmarkChannel(b, 10) }
func BenchmarkBuffer100(b *testing.B)  { benchmarkChannel(b, 100) }

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    // 设置管道：gen -> sq -> sq
    c := gen(2, 3)
    out := sq(sq(c))
    
    // 消费输出
    for n := range out {
        fmt.Println(n) // 16 then 81
    }
}

func merge(cs ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan int)
    
    // 为每个输入Channel启动一个输出goroutine
    output := func(c <-chan int) {
        for n := range c {
            out <- n
        }
        wg.Done()
    }
    wg.Add(len(cs))
    for _, c := range cs {
        go output(c)
    }
    
    // 启动goroutine在所有输出完成后关闭out
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

select {
case res := <-c:
    fmt.Println(res)
case <-time.After(1 * time.Second):
    fmt.Println("timeout")
}

func doWork(done <-chan struct{}, pulseInterval time.Duration) (<-chan struct{}, <-chan time.Time) {
    heartbeat := make(chan struct{})
    results := make(chan time.Time)
    go func() {
        defer close(heartbeat)
        defer close(results)
        
        pulse := time.Tick(pulseInterval)
        work := time.Tick(2 * pulseInterval)
        
        for {
            select {
            case <-done:
                return
            case <-pulse:
                heartbeat <- struct{}{}
            case r := <-work:
                results <- r
            }
        }
    }()
    return heartbeat, results
}

fatal error: all goroutines are asleep - deadlock!