Go语言实现生产者-消费者问题的多种方法

已于 2025-05-16 18:06:30 修改
阅读量753 收藏 12
点赞数 18
分类专栏： Go语言学习 文章标签： 中间件 go
于 2025-05-16 18:02:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52242569/article/details/148013180
版权

Go语言实现生产者-消费者问题的多种方法

生产者-消费者问题是并发编程中的经典问题，涉及多个生产者生成数据，多个消费者消费数据，二者通过缓冲区（队列）进行协调，保证数据的正确传递和同步。本文将从简单到复杂，使用不同的 Go 语言并发原语实现生产者-消费者模型，并详细介绍所用知识点。

目录

  1. 方法一：使用无缓冲 Channel（同步通信）
  2. 方法二：使用带缓冲 Channel（异步通信）
  3. 方法三：使用 sync.Mutex + 条件变量 sync.Cond 实现缓冲区
  4. 方法四：使用 Channel + select 实现多路复用和超时控制

方法一：使用无缓冲 Channel（同步通信）

知识点

  • 无缓冲 Channel：发送和接收必须同时准备好，适合严格同步的场景。
  • Goroutine：轻量级线程，使用 go 关键字启动。
  • sync.WaitGroup：等待所有 goroutine 完成。

代码示例

package main

import (
	"fmt"
	"sync"
	"time"
)

func producer(id int, ch chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < 3; i++ {
		item := id*100 + i
		fmt.Printf("生产者 %d 生产了产品 %d\n", id, item)
		ch <- item                         // 发送数据，阻塞直到有消费者接收
		time.Sleep(100 * time.Millisecond) // 模拟生产时间
	}
}

func consumer(id int, ch <-chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for item := range ch {
		fmt.Printf("消费者 %d 消费了产品 %d\n", id, item)
		time.Sleep(150 * time.Millisecond) // 模拟消费时间
	}
}

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

	var wg sync.WaitGroup

	// 启动生产者
	for i := 1; i <= 2; i++ {
		wg.Add(1)
		go producer(i, ch, &wg)
	}

	// 启动消费者
	for i := 1; i <= 2; i++ {
		wg.Add(1)
		go consumer(i, ch, &wg)
	}

	// 等待生产者完成
	wg.Wait()

	// 关闭 channel，通知消费者结束
	close(ch)

	// 由于消费者在 range 中消费，关闭后会退出
	// 这里主 goroutine 退出，程序结束
}

说明

  • 生产者发送数据时会阻塞，直到消费者接收，保证同步。
  • 适合生产和消费速度相近的场景。
  • 关闭 channel 后，消费者会自动退出。

方法二：使用带缓冲 Channel（异步通信）

知识点

  • 带缓冲 Channel：允许生产者先发送一定数量数据，消费者稍后接收，提升并发效率。
  • 生产者和消费者速度不匹配时，缓冲区能暂存数据，减少阻塞。

代码示例

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

func producer(id int, ch chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < 5; i++ {
		item := id*100 + i
		fmt.Printf("生产者 %d 生产了产品 %d\n", id, item)
		ch <- item
		time.Sleep(time.Duration(rand.Intn(300)) * time.Millisecond)
	}
}

func consumer(id int, ch <-chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for item := range ch {
		fmt.Printf("消费者 %d 消费了产品 %d\n", id, item)
		time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
	}
}

func main() {
	rand.Seed(time.Now().UnixNano())

	ch := make(chan int, 3) // 带缓冲 channel，缓冲区大小为3

	var wgProducers sync.WaitGroup
	var wgConsumers sync.WaitGroup

	// 启动生产者
	for i := 1; i <= 3; i++ {
		wgProducers.Add(1)
		go producer(i, ch, &wgProducers)
	}

	// 启动消费者
	for i := 1; i <= 2; i++ {
		wgConsumers.Add(1)
		go consumer(i, ch, &wgConsumers)
	}

	// 等待所有生产者完成
	wgProducers.Wait()

	// 关闭 channel，通知消费者没有更多数据
	close(ch)

	// 等待所有消费者完成
	wgConsumers.Wait()

	fmt.Println("所有生产者和消费者已完成工作，程序结束")
}

说明

  • 生产者可以先发送数据到缓冲区，不必等待消费者立即接收。
  • 缓冲区大小影响生产者和消费者的阻塞情况。
  • 关闭 channel 后，消费者会自动退出。

方法三：使用 sync.Mutex + sync.Cond 实现缓冲区（手动实现队列）

知识点

  • sync.Mutex：互斥锁，保护共享资源。
  • sync.Cond：条件变量，支持等待和通知机制。
  • 手动实现缓冲区：用切片模拟队列，生产者和消费者通过条件变量协调。

代码示例

package main

import (
	"fmt"
	"sync"
	"time"
)

type Buffer struct {
	items    []int
	size     int
	lock     sync.Mutex
	notEmpty *sync.Cond
	notFull  *sync.Cond
}

func NewBuffer(size int) *Buffer {
	b := &Buffer{
		items: make([]int, 0, size),
		size:  size,
	}
	b.notEmpty = sync.NewCond(&b.lock)
	b.notFull = sync.NewCond(&b.lock)
	return b
}

func (b *Buffer) Put(item int) {
	b.lock.Lock()
	defer b.lock.Unlock()

	// 如果缓冲区满，等待 notFull 信号
	for len(b.items) == b.size {
		b.notFull.Wait()
	}

	b.items = append(b.items, item)
	fmt.Printf("生产了产品 %d，缓冲区大小: %d\n", item, len(b.items))

	// 通知消费者缓冲区非空
	b.notEmpty.Signal()
}

func (b *Buffer) Get() int {
	b.lock.Lock()
	defer b.lock.Unlock()

	// 如果缓冲区空，等待 notEmpty 信号
	for len(b.items) == 0 {
		b.notEmpty.Wait()
	}

	item := b.items[0]
	b.items = b.items[1:]
	fmt.Printf("消费了产品 %d，缓冲区大小: %d\n", item, len(b.items))

	// 通知生产者缓冲区非满
	b.notFull.Signal()

	return item
}

func producer(id int, b *Buffer, count int, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < count; i++ {
		item := id*100 + i
		b.Put(item)
		time.Sleep(100 * time.Millisecond)
	}
}

func consumer(id int, b *Buffer, wg *sync.WaitGroup, done <-chan struct{}) {
	defer wg.Done()
	for {
		select {
		case <-done:
			return
		default:
			item := b.Get()
			time.Sleep(150 * time.Millisecond)
			fmt.Printf("消费者 %d 处理了产品 %d\n", id, item)
		}
	}
}

func main() {
	bufferSize := 5
	b := NewBuffer(bufferSize)

	var wgProducers sync.WaitGroup
	var wgConsumers sync.WaitGroup

	done := make(chan struct{})

	// 启动生产者
	numProducers := 2
	produceCount := 10
	for i := 1; i <= numProducers; i++ {
		wgProducers.Add(1)
		go producer(i, b, produceCount, &wgProducers)
	}

	// 启动消费者
	numConsumers := 3
	for i := 1; i <= numConsumers; i++ {
		wgConsumers.Add(1)
		go consumer(i, b, &wgConsumers, done)
	}

	// 等待生产者完成
	wgProducers.Wait()

	// 生产结束，等待缓冲区清空
	for {
		b.lock.Lock()
		empty := len(b.items) == 0
		b.lock.Unlock()
		if empty {
			break
		}
		time.Sleep(100 * time.Millisecond)
	}

	// 通知消费者退出
	close(done)

	// 等待消费者退出
	wgConsumers.Wait()

	fmt.Println("所有生产者和消费者已完成工作，程序结束")
}

说明

  • 手动实现缓冲区，生产者和消费者通过条件变量等待和通知。
  • 适合需要自定义缓冲区行为的场景。
  • 需要额外处理消费者退出逻辑。

方法四：使用 Channel + select 实现多路复用和超时控制

知识点

  • select：Go 语言中用于监听多个 channel 的操作，支持超时和默认分支。
  • 超时控制：防止 goroutine 永久阻塞。
  • 多路复用：同时监听多个事件。

代码示例

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func producer(id int, ch chan<- int, done <-chan struct{}) {
	for i := 0; i < 10; i++ {
		item := id*100 + i
		select {
		case ch <- item:
			fmt.Printf("生产者 %d 生产了产品 %d\n", id, item)
		case <-done:
			fmt.Printf("生产者 %d 收到退出信号\n", id)
			return
		}
		time.Sleep(time.Duration(rand.Intn(300)) * time.Millisecond)
	}
}

func consumer(id int, ch <-chan int, done <-chan struct{}) {
	for {
		select {
		case item, ok := <-ch:
			if !ok {
				fmt.Printf("消费者 %d 发现通道关闭，退出\n", id)
				return
			}
			fmt.Printf("消费者 %d 消费了产品 %d\n", id, item)
			time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
		case <-done:
			fmt.Printf("消费者 %d 收到退出信号\n", id)
			return
		case <-time.After(2 * time.Second):
			fmt.Printf("消费者 %d 超时退出\n", id)
			return
		}
	}
}

func main() {
	rand.Seed(time.Now().UnixNano())

	ch := make(chan int, 5)
	done := make(chan struct{})

	// 启动生产者
	for i := 1; i <= 3; i++ {
		go producer(i, ch, done)
	}

	// 启动消费者
	for i := 1; i <= 2; i++ {
		go consumer(i, ch, done)
	}

	// 运行一段时间后关闭生产者
	time.Sleep(5 * time.Second)
	close(done) // 通知所有 goroutine 退出

	// 关闭 channel，通知消费者没有更多数据
	close(ch)

	// 主 goroutine 等待一段时间让所有 goroutine 退出
	time.Sleep(3 * time.Second)
	fmt.Println("程序结束")
}

说明

  • 使用 select 监听多个 channel，支持超时和退出信号。
  • 生产者和消费者都能响应退出通知，优雅结束。
  • 适合复杂场景下的生产者-消费者模型。

总结

方法复杂度关键知识点适用场景
方法一简单无缓冲 channel，阻塞同步生产消费速度相近，简单同步
方法二中等带缓冲 channel，异步通信生产消费速度不匹配，提升效率
方法三较复杂sync.Mutex + sync.Cond，手动缓冲区需要自定义缓冲区行为，复杂同步
方法四复杂select 多路复用，超时控制，退出通知复杂场景，需多事件监听和优雅退出

Go 语言提供了丰富的并发原语，能够灵活实现生产者-消费者模型。根据实际需求和复杂度选择合适的方法，能让程序更高效、健壮。

Go语言中实现生产者-消费者模式的方法
class_class957的博客
09-20 102
通过无缓冲通道或带缓冲通道，我们可以在Go语言中实现生产者-消费者模式。无缓冲通道适合于需要严格控制发送和接收操作同步的场景，而带缓冲通道适合于生产者和消费者速度不匹配的情况。带缓冲通道是一种非阻塞式通道，它可以在缓冲区未满时进行发送操作，而无需等待接收方接收数据。关键字，我们在一个单独的goroutine中调用生产者函数，使其并发执行。无缓冲通道是一种阻塞式通道，它在发送和接收操作时会进行同步。在上面的代码中，我们与前面的示例相比，唯一的区别是在创建通道时使用了缓冲区大小为3的带缓冲通道。
67、Go语言并发编程：生产者-消费者模式深度解析
silenceallat的博客
06-25 1000
本文深入探讨了Go语言中的并发模式——生产者-消费者模式，通过实际案例展示了如何使用Go的通道和协程实现并发生产者和消费者。我们还介绍了如何处理缓冲区溢出和消费者错误，并探讨了生产者-消费者模式的进阶应用，包括优先级处理和工作窃取算法。这些内容帮助读者更好地理解并发编程原理，提升项目性能和效率。
go语言中实现生产者-消费者模式有哪些方法呢
chenjiazhanxiao的博客
05-22 1082
本文将介绍在 Go 语言中实现生产者消费者模式的多种方法，并重点探讨了通道、条件变量的适用场景和优缺点。我们将深入讨论这些方法的特点，以帮助开发者根据应用程序需求选择最适合的方式。通过灵活运用 Go 语言提供的并发原语，我们能够实现高效、可靠的生产者消费者模式，提升系统的并发性能和可维护性。生产者消费者模式是一种常见的并发编程模式，用于解决生产者和消费者之间的数据传递和处理问题。在该模式中，生产者负责生成数据（生产），而消费者负责处理数据（消费）。
生产者消费者模型
如无必要，勿增实体。
09-26 1018
生产者消费者模型（Producer-Consumer problem）是计算机科学中一个经典的并发问题，主要描述了两个或多个线程之间的数据共享和通信。在这个模型中，生产者线程负责生成数据，而消费者线程负责处理这些数据。为了实现高效的并发协作，通常会使用缓冲区来解耦生产者和消费者之间的直接通信。生产者消费者模型的核心思想是将生产数据和消费数据的过程解耦，从而提高系统的并发效率和扩展性。这种模型广泛应用于多线程编程中，以解决系统资源供需不平衡的问题。
青铜10：千锤百炼-如何解决生产者与消费者经典问题
MetaThoughts
06-16 921
欢迎来到《并发王者课》，本文是该系列文章中的第10篇。 在本篇文章中，我将为你介绍并发中的经典问题-生产者与消费者问题，并基于前面系列文章的知识点，通过wait、notify实现这一问题的简版方案。 一、生产者与消费者问题 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多进程、线程同步问题的经典案例。 这个问题描述了共享固定大小缓冲区的两个进程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产
Linux下的生产者-消费者模型多线程同步实现
weixin_42581846的博客
11-29 882
本文还有配套的精品资源，点击获取 简介：生产者-消费者模型是操作系统课程设计中的一个关键部分，通过模拟资源的生产与消耗来展示多线程同步和协作。在Linux系统中，结合pthread库、互斥锁和信号量等机制，可以使用C语言创建此模型。模型涉及互斥锁的资源保护、信号量的数量控制，以及调试和性能优化的必要步骤。通过本课程设计，学生可以加深对多线程编程和同步机制的理解，并在实践中学...
生产者消费者问题（Java和go实现）水文~
qq_43756091的博客
07-23 264
生产者消费者问题（Java和go实现） 介绍 维基百科介绍如下： 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多进程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个进程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也
快速学习GO语言总结
热门推荐
张彦峰的博客
12-04 5万+
针对有一定计算机语言基础人员快速掌握go语言，直接快速开始学习之旅
Go 如何通过 Kafka 客户端库 生产与消费消息
花想云的博客
05-27 1753
Go 如何通过 Kafka 客户端库 生产与消费消息
使用Go语言实现ActiveMQ生产者和消费者
4. Go语言操作ActiveMQ: Go-amq-poc演示了如何使用Go语言创建ActiveMQ的生产者和消费者。此POC（Proof of Concept，概念验证）展示了基本的消息发送和接收流程，有助于理解Go语言在实际企业应用开发中与消息队列交互...
Go通道应用模式：深入理解生产者-消费者模式的实现方式
生产者-消费者模式是一种多线程间协作的常用模式，该模式通过共享缓冲区实现了线程间的数据交换，解决了生产与消费速度不一致的问题。在IT行业中，无论是在系统内部各个模块间的数据处理，还是在分布式系统中跨服务...
【信号量实战】：揭秘高效解决生产者-消费者问题的秘诀
![【信号量实战】：揭秘高效解决生产...接着，通过实战演示了生产者和消费者在不同编程环境下的代码实现，并进行性能测试与分析。文章还探讨了多生产者-多消费者模型和信号量在其他领域的高级应用案例，提供了问题的优
中电金信参编的国家标准《信息技术 中间件 消息中间件技术要求》正式发布
zhongdianjinxin的博客
05-13 412
目前相关产品和解决方案已通过“源启”行业数字底座在多个重点工程项目中实现投产运行，并广泛应用于金融、能源等行业领域。消息中间件以高可靠异步通信能力，打通全域数据交互链路，为各行各业业务系统提供高效的通信保障，筑牢金融、能源、制造、政务及智慧城市等领域的业务连续性防线，实现跨系统、跨平台关键业务异步通信。未来，中电金信将以此次标准参编为契机，深耕中间件技术研发和产品升级，持续加强中间件标准化工作参与力度，形成标准与产品双向驱动模式，并依托“源启”行业数字底座，赋能金融、能源、制造等重点行业数智化转型。
中间件-MQ常见问题
zhujilisa的博客
05-15 954
所以处理消息积压第一个可以优化Consumer处理消息的效率，第二个可以增加Consumer实例的个数。如果此时再继续增加Consumer的实例，那么就会有些Consumer实例是没有MessageQueue去消费的，因此也就没有⽤了。然后把Consumer实例的Topic转向新的Topic，并紧急上线⼀组新的消费者，只负责消费旧Topic中的消息，并转存到新的Topic中。比如某个业务流程的消息有序。如果要快速处理积压的消息，可以创建⼀个新的Topic，配置⾜够多的MessageQueue。
第五部分：第五节 - Express 路由与中间件进阶：厨房的分工与异常处理
低代码布道师的博客
05-16 306
你可以把处理某个特定资源的路由（比如所有用户相关的路由）放到一个单独的文件中，然后像中间件一样将其挂载到主应用上。这就像在厨房里为不同的菜品（资源）设立了专门的操作台（路由文件），每个操作台有自己的工作流程，但它们最终都属于整个厨房（主应用）。随着你的 Express 应用变得越来越大，所有的路由和中间件都写在一个文件里会变得难以管理。并传入一个错误对象时，Express 会跳过后续的路由和中间件，直接进入错误处理中间件。和错误处理中间件的代码示例，将它们集成到一个完整的 Express 应用中。
Android framework 中间件开发(二)
田一一的博客
05-16 422
上篇文章中我们讲述了怎么去开发中间件, 这篇我们讲一下怎么打包中间件给外部应用使用目录 1.新建项目 2.编写jar包代码 3.打包jar包 4.使用jar包 我们可以直接将系统编译出来的framework的jar包拿出来直接用,但是为了安全起见,防止用户调用不该用的API,所以我们需要将framework的jar包再打包一层,只暴露需要的函数 framework的jar包位置:out\target\commo
mysql数据库-中间件MyCat
最新发布
2501_91384465的博客
05-17 176
语句优化、代码优化，数据库的处理本身优化也是非常重要的。协议与大多数主流数据库服务器通信，其核心功能是分表分库，即将一个大表水平分割为。时如果有分布式事务，得先看是否得保证事务得强一致性，否则请慎重使用。官方网站 http://www.mycat.org.cn/协议的服务器，前端用户可以把它看作是一个数据库代理（类似于。操作，要确保表的关联字段具有相同的数据分布，否则请慎重使用。是一个开源的分布式数据库系统，是一个实现了。客户端工具和命令行访问，而其后端可以用。服务器通信，也可以用。
从开发者角度看数据库架构进化史：JDBC - 中间件 - TiDB
TiDB 社区干货传送门
05-16 523
在业务开发早期，用 Java 借助 JDBC 进行数据库操作，虽能实现基本交互，但需手动管理连接、编写大量 SQL 及处理结果集，开发与维护成本高且易出错。随着业务发展，数据库表结构复杂，这种方式弊端凸显。为解决该问题，ORM 技术诞生。它将数据库表映射为 Java 类，使开发者能用面向对象方式操作数据库，提高开发效率、降低耦合度。 而企业级应用规模扩大、业务逻辑变复杂后，需要更有效的管理和组织。Spring 框架应运而生，它提供 IoC
解读RTOS 第七篇 · 驱动框架与中间件集成
hemoparrot的专栏
05-15 1194
本章将从驱动模型设计原则、CMSIS-Driver 规范深入讲解，再由 RT-Thread 组件化、DeviceTree 动态注册、U-Boot 驱动模型对比展开，最后详细演示 lwIP、FatFS、LVGL 和 FreeRTOS+CLI 的集成流程，附带完整源码示例、流程图与性能评估，确保读者能够在复杂项目中快速搭建高可靠、可扩展的 RTOS 驱动与中间件架构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值