简述一下Golong中无缓冲的 channel 和有缓冲的 channel 的区别？

八股文_Go机制 0 109

参考回答

在 Golang 中，无缓冲的 channel 和 有缓冲的 channel 是用于 Goroutine 间通信的两种主要类型：

无缓冲的 channel：
- 发送操作会阻塞，直到有 Goroutine 接收数据。
- 接收操作会阻塞，直到有 Goroutine 发送数据。
- 用于严格同步的场景。
有缓冲的 channel：
- 发送操作在缓冲未满时不会阻塞，直到缓冲区已满才会阻塞。
- 接收操作在缓冲区非空时不会阻塞，直到缓冲区为空才会阻塞。
- 用于需要异步通信的场景。

详细讲解与拓展

1. 无缓冲的 channel

无缓冲的 channel 在发送和接收之间实现了强同步：
– 发送方必须等到接收方准备好才能发送数据。
– 接收方必须等到发送方发送了数据才能接收。

代码示例：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int) // 无缓冲 channel

    go func() {
        ch <- 42 // 发送阻塞，直到有 Goroutine 接收
        fmt.Println("Sent 42")
    }()

    val := <-ch // 接收阻塞，直到有数据可读
    fmt.Println("Received:", val)
}

执行流程：
1. 子 Goroutine 试图发送 42，阻塞在 ch <- 42。
2. 主 Goroutine 接收到 42 后，发送方解除阻塞，执行 fmt.Println("Sent 42")。

特性：
– 确保发送和接收严格同步，数据不会在 channel 中滞留。
– 适合需要确保消息立即处理的场景，如任务分发。

2. 有缓冲的 channel

有缓冲的 channel 允许在发送和接收之间有一定的延迟。发送操作在缓冲区未满时不会阻塞，接收操作在缓冲区非空时不会阻塞。

代码示例：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 2) // 有缓冲 channel，大小为 2

    ch <- 1 // 不阻塞
    ch <- 2 // 不阻塞
    fmt.Println("Buffered channel is full now")

    go func() {
        ch <- 3 // 阻塞，直到有 Goroutine 接收
        fmt.Println("Sent 3")
    }()

    fmt.Println(<-ch) // 接收 1
    fmt.Println(<-ch) // 接收 2
}

执行流程：
1. ch <- 1 和 ch <- 2 直接存入缓冲区，不阻塞。
2. 当缓冲区已满时，ch <- 3 阻塞，直到缓冲区有空间。
3. 主 Goroutine 开始接收 1 和 2，缓冲区空出后，3 被写入。

特性：
– 发送和接收可以异步进行，减少阻塞。
– 适合需要暂存数据的场景，如生产者-消费者模型。

3. 区别总结

特性	无缓冲 channel	有缓冲 channel
阻塞条件	发送或接收双方必须同步完成	发送缓冲区满或接收缓冲区空时阻塞
数据存储	无缓冲区，直接传递数据	有缓冲区，可暂存多个数据
适用场景	强同步任务分发	异步生产者-消费者模型
并发控制	更适合并发控制和同步	更适合高吞吐量场景

4. 使用场景

无缓冲 channel 的场景：
– 需要保证发送和接收的严格同步。
– 用于 Goroutine 之间的信号传递或同步控制。

示例：同步控制

func worker(done chan bool) {
    fmt.Println("Working...")
    done <- true // 通知主协程
}

func main() {
    done := make(chan bool)
    go worker(done)
    <-done // 阻塞，直到收到信号
    fmt.Println("Done!")
}

有缓冲 channel 的场景：
– 需要缓冲消息，避免 Goroutine 阻塞。
– 用于生产者-消费者模型，多个 Goroutine 之间传递数据。

示例：生产者-消费者模型

func producer(ch chan int) {
    for i := 0; i < 5; i++ {
        fmt.Println("Producing:", i)
        ch <- i
    }
    close(ch)
}

func consumer(ch chan int) {
    for val := range ch {
        fmt.Println("Consuming:", val)
    }
}

func main() {
    ch := make(chan int, 3)
    go producer(ch)
    consumer(ch)
}

总结

无缓冲 channel：
- 强同步，发送和接收必须同时发生。
- 更适合同步操作或严格控制任务顺序的场景。
有缓冲 channel：
- 异步通信，发送方可以暂时存储数据，接收方稍后处理。
- 更适合高吞吐量、生产者-消费者模式。

选择哪种 channel 需要根据实际需求场景判断，并注意控制 Goroutine 的生命周期和缓冲区大小以避免死锁或资源浪费。