秒杀多线程第十篇 生产者消费者问题

    继经典线程同步问题之后,我们来看看生产者消费者问题及读者写者问题。生产者消费者问题是一个著名的线程同步问题,该问题描述如下:有一个生产者在生产产品,这些产品将提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个具有多个缓冲区的缓冲池,生产者将它生产的产品放入一个缓冲区中,消费者可以从缓冲区中取走产品进行消费,显然生产者和消费者之间必须保持同步,即不允许消费者到一个空的缓冲区中取产品,也不允许生产者向一个已经放入产品的缓冲区中再次投放产品。

    这个生产者消费者题目不仅常用于操作系统的课程设计,也常常在程序员和软件设计师考试中出现。并且在计算机考研的专业课考试中也是一个非常热门的问题。因此现在就针对这个问题进行详细深入的解答。

 

    首先来简化问题,先假设生产者和消费者都只有一个,且缓冲区也只有一个。这样情况就简便多了。

    第一.从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段互斥量来完成。

    第二.生产者要等待缓冲区为空,这样才可以投放产品,消费者要等待缓冲区不为空,这样才可以取出产品进行消费。并且由于有二个等待过程,所以要用二个事件信号量来控制。

    考虑这二点后,代码很容易写出来。另外为了美观起见,将消费者的输出颜色设置为彩色,有关如何在控制台下设置彩色输出请参阅《VC 控制台颜色设置》。

//1生产者 1消费者 1缓冲区
//使用二个事件,一个表示缓冲区空,一个表示缓冲区满。
//再使用一个关键段来控制缓冲区的访问
#include <stdio.h>
#include <process.h>
#include <windows.h>
//设置控制台输出颜色
BOOL SetConsoleColor(WORD wAttributes)
{
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	if (hConsole == INVALID_HANDLE_VALUE)
		return FALSE;	
	return SetConsoleTextAttribute(hConsole, wAttributes);
}
const int END_PRODUCE_NUMBER = 10;   //生产产品个数
int g_Buffer;                        //缓冲区
//事件与关键段
CRITICAL_SECTION g_cs;
HANDLE g_hEventBufferEmpty, g_hEventBufferFull;
//生产者线程函数
unsigned int __stdcall ProducerThreadFun(PVOID pM)
{
	for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
	{
		//等待缓冲区为空
		WaitForSingleObject(g_hEventBufferEmpty, INFINITE);

		//互斥的访问缓冲区
		EnterCriticalSection(&g_cs);
		g_Buffer = i;
		printf("生产者将数据%d放入缓冲区\n", i);
		LeaveCriticalSection(&g_cs);
		
		//通知缓冲区有新数据了
		SetEvent(g_hEventBufferFull);
	}
	return 0;
}
//消费者线程函数
unsigned int __stdcall ConsumerThreadFun(PVOID pM)
{
	volatile bool flag = true;
	while (flag)
	{
		//等待缓冲区中有数据
		WaitForSingleObject(g_hEventBufferFull, INFINITE);
		
		//互斥的访问缓冲区
		EnterCriticalSection(&g_cs);
		SetConsoleColor(FOREGROUND_GREEN);
		printf("  消费者从缓冲区中取数据%d\n", g_Buffer);
		SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		if (g_Buffer == END_PRODUCE_NUMBER)
			flag = false;
		LeaveCriticalSection(&g_cs);
		
		//通知缓冲区已为空
		SetEvent(g_hEventBufferEmpty);

		Sleep(10); //some other work should to do
	}
	return 0;
}
int main()
{
	printf("  生产者消费者问题   1生产者 1消费者 1缓冲区\n");
	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

	InitializeCriticalSection(&g_cs);
	//创建二个自动复位事件,一个表示缓冲区是否为空,另一个表示缓冲区是否已经处理
	g_hEventBufferEmpty = CreateEvent(NULL, FALSE, TRUE, NULL);
	g_hEventBufferFull = CreateEvent(NULL, FALSE, FALSE, NULL);
	
	const int THREADNUM = 2;
	HANDLE hThread[THREADNUM];
	
	hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
	hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
	WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
	CloseHandle(hThread[0]);
	CloseHandle(hThread[1]);
	
	//销毁事件和关键段
	CloseHandle(g_hEventBufferEmpty);
	CloseHandle(g_hEventBufferFull);
	DeleteCriticalSection(&g_cs);
	return 0;
}

运行结果如下所示:

可以看出生产者与消费者已经是有序的工作了。

 

    然后再对这个简单生产者消费者问题加大难度。将消费者改成2个,缓冲池改成拥有4个缓冲区的大缓冲池。

    如何来思考了这个问题了?首先根据上面分析的二点,可以知道生产者和消费者由一个变成多个的影响不大,唯一要注意的是缓冲池变大了,回顾一下《秒杀多线程第八篇 经典线程同步 信号量Semaphore》中的信号量,不难得出用二个信号量就可以解决这种缓冲池有多个缓冲区的情况——用一个信号量A来记录为空的缓冲区个数,另一个信号量B记录非空的缓冲区个数,然后生产者等待信号量A,消费者等待信号量B就可以了。因此可以仿照上面的代码来实现复杂生产者消费者问题,示例代码如下:

//1生产者 2消费者 4缓冲区
#include <stdio.h>
#include <process.h>
#include <windows.h>
//设置控制台输出颜色
BOOL SetConsoleColor(WORD wAttributes)
{
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	if (hConsole == INVALID_HANDLE_VALUE)
		return FALSE;
	
	return SetConsoleTextAttribute(hConsole, wAttributes);
}
const int END_PRODUCE_NUMBER = 8;  //生产产品个数
const int BUFFER_SIZE = 4;          //缓冲区个数
int g_Buffer[BUFFER_SIZE];          //缓冲池
int g_i, g_j;
//信号量与关键段
CRITICAL_SECTION g_cs;
HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;
//生产者线程函数
unsigned int __stdcall ProducerThreadFun(PVOID pM)
{
	for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
	{
		//等待有空的缓冲区出现
		WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);

		//互斥的访问缓冲区
		EnterCriticalSection(&g_cs);
		g_Buffer[g_i] = i;
		printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);
		g_i = (g_i + 1) % BUFFER_SIZE;
		LeaveCriticalSection(&g_cs);

		//通知消费者有新数据了
		ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
	}
	printf("生产者完成任务,线程结束运行\n");
	return 0;
}
//消费者线程函数
unsigned int __stdcall ConsumerThreadFun(PVOID pM)
{
	while (true)
	{
		//等待非空的缓冲区出现
		WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
		
		//互斥的访问缓冲区
		EnterCriticalSection(&g_cs);
		SetConsoleColor(FOREGROUND_GREEN);
		printf("  编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);
		SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志
		{
			LeaveCriticalSection(&g_cs);
			//通知其它消费者有新数据了(结束标志)
			ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
			break;
		}
		g_j = (g_j + 1) % BUFFER_SIZE;
		LeaveCriticalSection(&g_cs);

		Sleep(50); //some other work to do

		ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);
	}
	SetConsoleColor(FOREGROUND_GREEN);
	printf("  编号为%d的消费者收到通知,线程结束运行\n", GetCurrentThreadId());
	SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
	return 0;
}
int main()
{
	printf("  生产者消费者问题   1生产者 2消费者 4缓冲区\n");
	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

	InitializeCriticalSection(&g_cs);
	//初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.
	g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);
	g_hSemaphoreBufferFull  = CreateSemaphore(NULL, 0, 4, NULL);
	g_i = 0;
	g_j = 0;
	memset(g_Buffer, 0, sizeof(g_Buffer));

	const int THREADNUM = 3;
	HANDLE hThread[THREADNUM];
	//生产者线程
	hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
	//消费者线程
	hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
	hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
	WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
	for (int i = 0; i < THREADNUM; i++)
		CloseHandle(hThread[i]);

	//销毁信号量和关键段
	CloseHandle(g_hSemaphoreBufferEmpty);
	CloseHandle(g_hSemaphoreBufferFull);
	DeleteCriticalSection(&g_cs);
	return 0;
}

运行结果如下图所示:

输出结果证明各线程的同步和互斥已经完成了。

 

至此,生产者消费者问题已经圆满的解决了,下面作个总结:

1.首先要考虑生产者与消费者对缓冲区操作时的互斥。

2.不管生产者与消费者有多少个,缓冲池有多少个缓冲区。都只有二个同步过程——分别是生产者要等待有空缓冲区才能投放产品,消费者要等待有非空缓冲区才能去取产品。

 

下一篇《秒杀多线程第十一篇读者写者问题》将介绍另一个著名的同步问题——读者写者问题,欢迎大家再来参阅。

 

转载请标明出处,原文地址:http://blog.csdn.net/morewindows/article/details/7577591

如果觉得本文对您有帮助,请点击‘顶’支持一下,您的支持是我写作最大的动力,谢谢。

 

<think>嗯,用户想要准备关于消息队列的面试问题和答案。首先,我需要回顾之前提供的引用内容,看看哪些信息可以直接使用。引用1列出了10个问题,用户可能希望这些都有答案。然后引用2到4提供了部分细节,比如高可靠性、持久化、参数配置,还有Producer的角色。 用户的需求是常见问题及答案,所以需要覆盖引用里的所有点,同时可能还要补充一些常见的面试问题。比如消息队列的基本概念、应用场景、消息丢失、顺序性、重复消费、积压处理、选型、高可用、数据一致性、事务消息、架构设计等。 接下来,我需要把每个问题拆解,给出简明扼要的答案,并适当引用提供的参考文献。例如,在回答消息丢失问题时,可以结合引用2提到的持久化、副本机制和消息确认机制。处理重复消费时,引用1提到了幂等处理,需要解释如何实现。 另外,用户提供的引用3提到了线上故障的例子,可以用于消息积压问题的回答,说明实际场景中的处理方法。引用4则定义了Producer的角色,可能在第一个问题或应用场景中提到。 需要注意的是,答案要结构清晰,分点回答,每个问题先解释基本概念,再给出解决方案或关键点。同时,确保使用正确的中文表达,避免技术术语错误,并且每个引用要自然地标注在相关段落的末尾。 可能还需要检查是否有遗漏的问题点,比如消息队列的优缺点,或者与其他技术的对比,但根据引用内容,主要覆盖那10个问题应该足够。最后,要确保每个答案准确,并且引用正确的来源,帮助用户有效准备面试。</think># 消息队列面试常见问题与答案 --- ### 1. 消息队列的应用场景有哪些? - **解耦**:生产者消费者通过消息队列异步通信,降低系统耦合度[^1]。 - **削峰填谷**:突发流量时缓存请求,避免系统过载(如电商秒杀场景)[^1]。 - **异步处理**:耗时操作异步执行(如订单支付后发送短信通知)。 - **数据同步**:跨系统数据同步(如数据库与缓存同步)[^1]。 --- ### 2. 如何解决消息丢失问题? - **生产者端**:启用事务消息或确认机制(如RabbitMQ的`confirm模式`、Kafka的`ACK=all`)[^2]。 - **Broker端**:启用持久化存储(消息落盘),配置副本机制(如Kafka的ISR副本同步)[^2]。 - **消费者端**:手动提交偏移量(避免自动提交导致未处理完成的消息丢失)[^2]。 --- ### 3. 如何保证消息顺序性? - **单分区/队列顺序**:Kafka通过同一分区的消息顺序写入实现;RabbitMQ需单队列单消费者[^1]。 - **业务层标识**:通过消息键(如订单ID)将相关消息路由到同一分区/队列。 --- ### 4. 如何避免消息重复消费? - **幂等性设计**:消费者对重复消息做去重判断(如数据库唯一键、Redis记录已处理ID)。 - **业务状态机**:通过状态字段判断消息是否已处理(如订单状态从"未支付"到"已支付")[^1]。 --- ### 5. 如何处理消息积压? - **临时扩容**:增加消费者实例或线程数(需注意分区/队列数量限制)[^3]。 - **跳过非关键消息**:丢弃旧消息或降级处理(如日志类消息)[^3]。 - **优化消费逻辑**:提升单条消息处理效率(如批量操作、异步处理)[^3]。 --- ### 6. Kafka、RabbitMQ、RocketMQ如何选型? | 特性 | Kafka | RabbitMQ | RocketMQ | |---------------|--------------------|--------------------|-------------------| | 吞吐量 | 百万级/秒 | 万级/秒 | 十万级/秒 | | 延迟 | 毫秒级 | 微秒级 | 毫秒级 | | 可靠性 | 高(副本同步) | 高(镜像队列) | 非常高(事务消息)| | 适用场景 | 日志、大数据流 | 企业级系统解耦 | 金融级事务场景 | --- ### 7. 如何实现消息队列高可用? - **集群模式**:Kafka使用多Broker+分区副本;RabbitMQ使用镜像队列;RocketMQ多Master-Slave架构。 - **自动故障转移**:通过ZooKeeper或Raft协议实现Leader选举。 --- ### 8. 如何保证数据一致性? - **事务消息**:RocketMQ的"半消息"机制,先预提交消息,业务成功后再提交确认[^1]。 - **最终一致性**:通过重试机制+死信队列保证最终达成一致。 --- ### 9. 如果让你设计消息队列,核心模块有哪些? 1. **网络层**:基于Netty实现高性能通信 2. **存储层**:顺序写磁盘+零拷贝技术(如Kafka的LogSegment) 3. **高可用**:副本同步机制(如ISR列表) 4. **扩展性**:分区/分片机制支持水平扩展 5. **监控**:消息堆积报警、吞吐量监控 --- ### 10. 实际案例:订单系统如何用消息队列? 1. 下单后发送`订单创建`消息到队列 2. 库存服务消费消息并扣减库存 3. 支付服务异步监听支付结果并更新订单状态 4. 使用延迟队列处理30分钟未支付订单的自动关闭 §§ 进阶问题 §§ 1. 如何实现延迟队列?(Kafka时间轮 vs RabbitMQ死信队列) 2. 如何设计消息回溯功能? 3. 消息队列如何与微服务架构结合?
评论 127
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值