Go语言中生产者消费者模式通过goroutine和channel实现，生产者发送数据到带缓冲channel，消费者从中接收并处理；使用sync.WaitGroup确保所有生产者完成后由主协程关闭channel，避免panic；结合select与time.After可实现超时控制，提升健壮性；还可通过channel传递Task函数实现任务队列；合理设计缓冲大小与生命周期管理是关键。

在Go语言中，生产者消费者模式可以通过goroutine和channel高效实现。由于Go原生支持并发，使用channel作为协程间通信的机制，天然适合处理这类问题。核心思路是：生产者将数据发送到channel，消费者从channel接收数据，channel起到缓冲和同步的作用。

基本结构：定义生产者与消费者

一个典型的实现包含一个或多个生产者goroutine，一个或多个消费者goroutine，以及一个带缓冲的channel用于解耦生产和消费速度。

示例代码：

func producer(ch chan<- int, id int) {
    for i := 0; i < 5; i++ {
        ch <- i*10 + id
        fmt.Printf("Producer %d sent: %d\n", id, i*10+id)
        time.Sleep(time.Millisecond * 100) // 模拟耗时
    }
}
<p>func consumer(ch <-chan int, id int) {
for data := range ch {
fmt.Printf("Consumer %d received: %d\n", id, data)
time.Sleep(time.Millisecond * 150) // 模拟处理时间
}
}</p>

主函数中启动多个生产者和消费者：

立即学习“go语言免费学习笔记（深入）”；

ch := make(chan int, 10) // 带缓冲的channel
<p>// 启动多个生产者
for i := 0; i < 3; i++ {
go producer(ch, i)
}</p><p>// 启动多个消费者
for i := 0; i < 2; i++ {
go consumer(ch, i)
}</p><p>// 等待一段时间让任务完成（实际中可用WaitGroup）
time.Sleep(3 <em> time.Second)
close(ch) // 关闭channel通知消费者结束
time.Sleep(1 </em> time.Second)</p>

控制关闭：避免向已关闭的channel发送数据

关键点是不能由多个生产者直接关闭channel，因为这会导致panic。正确的做法是使用sync.WaitGroup等待所有生产者完成，再由主协程关闭channel。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

改进后的生产者管理：

var wg sync.WaitGroup
<p>// 生产者函数增加wg Done
func producer(ch chan<- int, id int) {
defer wg.Done()
for i := 0; i < 5; i++ {
ch <- i*10 + id
}
}</p><p>// 主协程中：
for i := 0; i < 3; i++ {
wg.Add(1)
go producer(ch, i)
}</p><p>go func() {
wg.Wait()
close(ch) // 所有生产者结束后关闭
}()</p>

提升灵活性：使用select处理多channel与超时

在实际应用中，消费者可能需要处理多个输入源或防止永久阻塞。使用select可以监听多个channel，结合timeout提升健壮性。

例如：

func consumerWithTimeout(ch <-chan int, id int) {
    for {
        select {
        case data, ok := <-ch:
            if !ok {
                fmt.Printf("Consumer %d exiting.\n", id)
                return
            }
            fmt.Printf("Consumer %d got: %d\n", id, data)
        case <-time.After(500 * time.Millisecond):
            fmt.Printf("Consumer %d timed out, checking exit...\n", id)
            return
        }
    }
}

动态扩展：通过channel传递任务函数

更高级的用法是传递函数而非数据，实现任务队列。例如：

type Task func()
<p>taskCh := make(chan Task, 10)</p><p>go func() {
for task := range taskCh {
task() // 执行任务
}
}()</p><p>// 提交任务
taskCh <- func() {
fmt.Println("Executing task...")
}</p>

基本上就这些。Go的channel让生产者消费者模式变得简洁且安全，关键是合理设计缓冲大小、正确关闭channel，并根据场景选择是否使用WaitGroup或context控制生命周期。