C++实现经典同步问题（生产者消费者、读者写者、哲学家进餐、吸烟者问题）

已于 2022-07-06 17:28:38 修改
阅读量4.3k 收藏 166
点赞数 17
分类专栏： C++实现王道考研操作系统经典同步问题 文章标签： c++ 开发语言 windows
于 2022-07-06 16:37:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jasean_/article/details/125642136
版权

一、生产者 - 消费者问题

  • 环境：windows

问题描述：
一组生产者进程和一组消费者进程共享一个初始为空、大小为〃的缓冲区，只有缓冲区没满时，生产者才能把消息放入缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从中取出消息，否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或一个消费者从中取出消息。

代码：

#include <Windows.h>

#include <iostream>
#include <stdlib.h>

typedef HANDLE Semaphore;
#define P(S) WaitForSingleObject(S, INFINITE)
#define V(S) ReleaseSemaphore(S, 1, NULL)

int produceId = 1000;	//生产的的产品ID
int consumeId;			//消费的产品ID
int buf[10];			//用于存放缓存中的数据
int BUFSIZE = 10;	//缓存大小
int in = 0;				//用于表示生产者放入缓存的下表索引
int out = 0;			//用于表示消费者从缓存中那组的数据的下标索引

//初始化empty互斥量，初值为10，表示空的缓存数
Semaphore empty = CreateSemaphore(
	NULL,
	10,
	10,
	NULL
);

//初始化互斥量，用户互斥访问临界资源
Semaphore mutex = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

//初始化full互斥量，初值为0，用于表示缓存中放了多少份数据
Semaphore full = CreateSemaphore(
	NULL,
	0,
	10,
	NULL
);

DWORD WINAPI Producer(LPVOID);	//生产者线程函数
DWORD WINAPI Consumer(LPVOID);	//消费者线程函数

VOID Produce();			//生产者生产数据 的函数
VOID Consume();			//消费者消费数据的函数 

VOID printbuf();		//用于打印缓存中的数据的函数


int main()
{
    
	HANDLE produce;
	HANDLE consumer1, consumer2, consumer3;

	produce = CreateThread(
		NULL,
		0,
		Producer,
		NULL,
		0,
		NULL
	);
	consumer1 = CreateThread(
		NULL,
		0,
		Consumer,
		NULL,
		0,
		NULL
	);
	consumer2 = CreateThread(
		NULL,
		0,
		Consumer,
		NULL,
		0,
		NULL
	);
	consumer3 = CreateThread(
		NULL,
		0,
		Consumer,
		NULL,
		0,
		NULL
	);
	while (1)
	{
		WaitForSingleObject(produce, INFINITE);
		WaitForSingleObject(consumer1, INFINITE);
		WaitForSingleObject(consumer2, INFINITE);
		WaitForSingleObject(consumer3, INFINITE);
	}

	return 0;
}

VOID printbuf() {
	std::cout << "缓存中的数据：";
	bool hasData = false;
	for (int i = 0; i < BUFSIZE; i++) {
		if (buf[i] != 0) {
			std::cout << buf[i] << "----";
			hasData = true;
		}
	}
	if (hasData)
		std::cout << std::endl;
	else
		std::cout << "无" << std::endl;
}

VOID Produce() {
	produceId++;
	buf[in++] = produceId;
	std::cout << "我是生产者，我生产了：" << produceId << std::endl;
	printbuf();
	in %= BUFSIZE;
}

VOID Consume() {
	consumeId = buf[out];
	std::cout << "我是消费者，我消费了：" << consumeId << std::endl;
	buf[out++] = 0;
	printbuf();
	out %= BUFSIZE;
}

DWORD WINAPI Producer(LPVOID) {
	while (1) {
		P(empty);		//有无空缓存
		P(mutex);		//互斥夹紧临界资源
		Produce();		//生产数据
		Sleep(1000);
		V(mutex);		//互斥夹紧临界资源
		V(full);		//full值+1
	}
	return 0;
}

DWORD WINAPI Consumer(LPVOID) {
	while (1) {
		P(full);		//缓存中有无数据
		P(mutex);		//互斥夹紧临界资源
		Consume();		//消费数据
		Sleep(1000);
		V(mutex);		//互斥夹紧临界资源
		V(empty);		//空缓存数加1
	}
	return 0;
}

运行效果：
在这里插入图片描述

再来看一个复杂一点的生产者 - 消费者问题：
桌子上有一个盘子，每次只能向其中放入一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专等吃盘子中的橘子，女儿专等吃盘子中的苹果。只有盘子为空时， 爸爸或妈妈才可向盘子中放一个水果；仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取岀。

代码：

#include <Windows.h>

#include <iostream>
#include <stdlib.h>

typedef HANDLE Semaphore;
#define P(S) WaitForSingleObject(S, INFINITE)
#define V(S) ReleaseSemaphore(S, 1, NULL)

#define _NULL 0
#define _APPLE 1
#define _ORANGE 2
#define _FATHER 1
#define _MOTHER 2
#define _SON 3
#define _DAUGHTER 4

int what = 0;			//用于表示是哪种水果
int who = 0;			//用于表示是哪位放了或者吃了水果

//初始化apple互斥量，初值为0，用于表示盘中是否放了苹果
Semaphore apple = CreateSemaphore(
	NULL,
	0,
	1,
	NULL
);

//初始化orange互斥量，初值为0，用于表示盘中是否放了橘子
Semaphore orange = CreateSemaphore(
	NULL,
	0,
	1,
	NULL
);

//初始化plate互斥量，用于表示盘中是否有水果
Semaphore plate = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

DWORD WINAPI Father(LPVOID);	//父亲线程函数
DWORD WINAPI Mother(LPVOID);	//母亲线程函数
DWORD WINAPI Son(LPVOID);		//儿子线程函数
DWORD WINAPI Daughter(LPVOID);	//女儿线程函数

VOID Put(int);			//父母放水果的函数
VOID Get();				//儿女吃水果的函数 

VOID PrintPlate();		//用于打印的函数


int main()
{

	HANDLE father, mother, son, daughter;;

	father = CreateThread(
		NULL,
		0,
		Father,
		NULL,
		0,
		NULL
	);
	mother = CreateThread(
		NULL,
		0,
		Mother,
		NULL,
		0,
		NULL
	);
	son = CreateThread(
		NULL,
		0,
		Son,
		NULL,
		0,
		NULL
	);
	daughter = CreateThread(
		NULL,
		0,
		Daughter,
		NULL,
		0,
		NULL
	);
	while (1)
	{
		WaitForSingleObject(father, INFINITE);
		WaitForSingleObject(mother, INFINITE);
		WaitForSingleObject(son, INFINITE);
		WaitForSingleObject(daughter, INFINITE);
	}

	return 0;
}

VOID PrintPlate() {
	std::string _who[4] = {
		"爸爸",
		"妈妈",
		"儿子",
		"女儿"
	};
	std::string _what[2] = {
		"苹果",
		"橘子"
	};
	if (who == _FATHER || who == _MOTHER) {
		std::cout << "我是：" << _who[who - 1].c_str()
			<< "；  我放了【" << _what[what - 1].c_str() << "】在盘子里...."
			<< std::endl;
	}
	else {
		std::cout << "我是：" << _who[who - 1].c_str()
			<< "；  我从盘子里把【" << _what[what - 1].c_str() << "】拿走了...."
			<< std::endl;
	}
}

VOID Put(int id) {
	what = (id == _APPLE) ? _APPLE : _ORANGE;
	who = (id == _FATHER) ? _FATHER : _MOTHER;
	PrintPlate();
}

VOID Get() {
	who = (what == _APPLE) ? _DAUGHTER : _SON;
	PrintPlate();
	what = _NULL;
}

DWORD WINAPI Father(LPVOID) {
	while (1) {
		P(plate);				//看盘子是否为空
		Put(_APPLE);			//父亲放入苹果
		Sleep(1000);
		V(apple);				//唤醒女儿线程
	}
	return 0;
}

DWORD WINAPI Mother(LPVOID) {
	while (1) {
		P(plate);				//看盘子是否为空
		Put(_ORANGE);			//母亲放入橘子
		Sleep(1000);
		V(orange);				//唤醒儿子线程
	}
	return 0;
}

DWORD WINAPI Son(LPVOID) {
	while (1) {
		P(orange);				//看盘子里是否有橘子
		Get();					//拿走橘子
		Sleep(1000);
		V(plate);				//盘子变空，唤醒父母
	}
	return 0;
}

DWORD WINAPI Daughter(LPVOID) {
	while (1) {
		P(apple);				//看盘子里是否有苹果
		Get();					//拿走苹果
		Sleep(1000);
		V(plate);				//盘子变空，唤醒父母
	}
	return 0;
}

运行效果：
在这里插入图片描述

二、读者 - 写者问题

问题描述：
有读者和写者两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程(读进程或写进程)同时访问共享数据时则可能导致数据不一致的错误。因此要求：①允许多个读者可以同时对文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。

读优先（读优先可能会导致写者线程饿死）的代码：

//读者优先，读者优先可能导致写进程饿死
#include <Windows.h>

#include <iostream>
#include <stdlib.h>

typedef HANDLE Semaphore;
#define P(S) WaitForSingleObject(S, INFINITE)
#define V(S) ReleaseSemaphore(S, 1, NULL)

int count = 0;			//用于记录读者数量

//初始化mutex互斥量，用于保证互斥访问count
Semaphore mutex = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

//初始化rw互斥量，用于保证读写进程 互斥地访问文件
Semaphore rw = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

DWORD WINAPI Reader(LPVOID);	//读者线程函数
DWORD WINAPI Writer(LPVOID);	//写者线程函数

VOID Read();				//读函数
VOID Write();				//写函数


int main()
{

	HANDLE reader[5];
	HANDLE writer[5];

	for (int i = 0; i < 5; i++) {
		reader[i] = CreateThread(
			NULL,
			0,
			Reader,
			NULL,
			0,
			NULL
		);
	}

	for (int i = 0; i < 5; i++) {
		writer[i] = CreateThread(
			NULL,
			0,
			Writer,
			NULL,
			0,
			NULL
		);
	}

	while (1)
	{
		for (int i = 0; i < 20; i++)
			WaitForSingleObject(reader[i], INFINITE);
		
		for (int i = 0; i < 5; i++)
			WaitForSingleObject(writer[i], INFINITE);
	}

	return 0;
}

VOID Read() {
	std::cout << "我是读线程，我正在读......." << std::endl;
}

VOID Write() {
	std::cout << "我是写线程，我正在写---------------" << std::endl;
}

DWORD WINAPI Reader(LPVOID) {
	while (1) {
		P(mutex);			//互斥访问count变量
		if (count == 0)		//当第一个读线程读共享文件时
			P(rw);			//阻塞写线程
		count++;			//读线程数加 1
		Sleep(1000);
		V(mutex);			//互斥访问count变量
		Read();				//读取共享文件
		P(mutex);			//互斥访问count变量
		count--;			//读线程数减 1
		if (count == 0)		//当当前没有读线程工作时
			V(rw);			//释放rw信号量，通知写线程可以工作了
		V(mutex);			//互斥访问count变量
	}
	return 0;
}

DWORD WINAPI Writer(LPVOID) {
	while (1) {
		P(rw);				//保证互斥访问共享文件
		Write();			//写共享文件
		Sleep(300);
		V(rw);				//保证互斥访问共享文件
	}
	return 0;
}

运行效果：
在这里插入图片描述
注：可以看到，由于读者线程优先，导致了写者线程饿死

写优先，或者叫读写平衡的代码：

//写者优先，或者叫读写平衡
#include <Windows.h>

#include <iostream>
#include <stdlib.h>

typedef HANDLE Semaphore;
#define P(S) WaitForSingleObject(S, INFINITE)
#define V(S) ReleaseSemaphore(S, 1, NULL)

int count = 0;			//用于记录读者数量

//初始化mutex互斥量，用于保证互斥访问count
Semaphore mutex = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

//初始化rw互斥量，用于保证读写进程 互斥地访问文件
Semaphore rw = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

//初始化w互斥量，用于实现“写优先”
Semaphore w = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

DWORD WINAPI Reader(LPVOID);	//读者线程函数
DWORD WINAPI Writer(LPVOID);	//写者线程函数

VOID Read();				//读函数
VOID Write();				//写函数


int main()
{

	HANDLE reader[5];
	HANDLE writer[5];

	for (int i = 0; i < 5; i++) {
		reader[i] = CreateThread(
			NULL,
			0,
			Reader,
			NULL,
			0,
			NULL
		);
	}

	for (int i = 0; i < 5; i++) {
		writer[i] = CreateThread(
			NULL,
			0,
			Writer,
			NULL,
			0,
			NULL
		);
	}

	while (1)
	{
		for (int i = 0; i < 20; i++)
			WaitForSingleObject(reader[i], INFINITE);

		for (int i = 0; i < 5; i++)
			WaitForSingleObject(writer[i], INFINITE);
	}

	return 0;
}

VOID Read() {
	std::cout << "我是读线程，我正在读......." << std::endl;
}

VOID Write() {
	std::cout << "我是写线程，我正在写---------------" << std::endl;
}

DWORD WINAPI Reader(LPVOID) {
	while (1) {
		P(w);				//保证在无写线程时进入
		P(mutex);			//互斥访问count变量
		if (count == 0)		//当第一个读线程读共享文件时
			P(rw);			//阻塞写线程
		count++;			//读线程数加 1
		Sleep(1000);
		V(mutex);			//互斥访问count变量
		V(w);				//释放w，保证写线程优先
		Read();				//读取共享文件
		P(mutex);			//互斥访问count变量
		count--;			//读线程数减 1
		if (count == 0)		//当当前没有读线程工作时
			V(rw);			//释放rw信号量，通知写线程可以工作了
		V(mutex);			//互斥访问count变量
	}
	return 0;
}

DWORD WINAPI Writer(LPVOID) {
	while (1) {
		P(w);				//在无写线程时进入
		P(rw);				//保证互斥访问共享文件
		Write();			//写共享文件
		Sleep(300);
		V(rw);				//保证互斥访问共享文件
		V(w);				//写完毕，释放
	}
	return 0;
}

运行效果：
在这里插入图片描述
注：可以看到写者线程被调度了

三、哲学家进餐问题

问题描述：
一张圆桌边上坐着5名哲学家，每两名哲学家之间的桌上摆一根筷子，两根筷子中间是一碗米饭，如图2.12所示。哲学家们倾注毕生精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子（一根一根地拿起）。若筷子已在他人手上，则需要等待。饥饿的哲学家只有同时拿到了两根筷子才可以开始进餐，进餐完毕后，放下筷子继续思考。

代码：

#include <Windows.h>

#include <iostream>
#include <stdlib.h>

typedef HANDLE Semaphore;
#define P(S) WaitForSingleObject(S, INFINITE)
#define V(S) ReleaseSemaphore(S, 1, NULL)

//筷子互斥量，初值为1，表示是否有筷子
Semaphore chopstick[5];

//初始化mutex互斥量，用于保证互斥访问chopstick
Semaphore mutex = CreateSemaphore(
	NULL,
	1,
	1,
	NULL
);

DWORD WINAPI Philosopher(LPVOID);	//哲学家线程函数

VOID InitSemaphore();

VOID Eat(int);							//哲学家进餐函数
VOID Think(int);						//哲学家思考函数

int main()
{
	InitSemaphore();

	HANDLE philosopher[5];
	int id[5];
	for (int i = 0; i < 5; i++)
		id[i] = i;

	for (int i = 0; i < 5; i++) {
		philosopher[i] = CreateThread(
			NULL,
			0,
			Philosopher,
			(LPVOID)&(id[i]),
			0,
			NULL
		);
	}

	while (1)
	{
		for (int i = 0; i < 5; i++)
			WaitForSingleObject(philosopher[i], INFINITE);
	}

	return 0;
}

VOID InitSemaphore() {
	for (int i = 0; i < 5; i++) {
		chopstick[i] = CreateSemaphore(
			NULL,
			1,
			1,
			NULL
		);
	}
}

VOID Eat(int i) {
	std::cout << "哲学家【" << i + 1 << "】正在进餐..." << std::endl;
}

VOID Think(int i) {
	std::cout << "哲学家【" << i + 1 << "】正在思考........" << std::endl;
}

DWORD WINAPI Philosopher(LPVOID i) {
	while (1) {
		P(mutex);								//互斥访问筷子
		P(chopstick[*((int *)i)]);				//拿起左手边的筷子
		P(chopstick[((*((int *)i)) + 1) % 5]);	//拿起右手边的筷子
		V(mutex);								//互斥访问筷子
		Eat(*(int *)i);							//进餐
		Sleep(1000);
		V(chopstick[*((int *)i)]);				//放下左手边的筷子
		V(chopstick[((*((int *)i) + 1)) % 5]);	//放下右手边的筷子
		Think(*(int *)i);						//思考.....在这里可能发生竟态条件
	}
	return 0;
}

运行效果：
在这里插入图片描述
注：以上思考的输出出现混乱的原因：

在一个哲学家线程调用到 Think 函数的时候由于没有信号量的保护，因此可能发生竟态条件，由于线程异步地执行，可能在某个线程运行 Think 的时候发生了调度。

四、吸烟者问题

问题描述：
假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但要卷起并抽掉一支烟，抽烟者需要有三种材料：烟草、纸和胶水。三个抽烟者中，第一个拥有烟草，第二个拥有纸，第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放到桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者一个信号告诉已完成，此时供应者就会将另外两种材料放到桌上，如此重复（让三个抽烟者轮流地抽烟）。

代码：

#include <Windows.h>

#include <iostream>
#include <stdlib.h>

typedef HANDLE Semaphore;
#define P(S) WaitForSingleObject(S, INFINITE)
#define V(S) ReleaseSemaphore(S, 1, NULL)

#define YanCaoAndZhi 1
#define YanCaoAndJiaoShui 2
#define ZhiAndJiaoShui 3

int num;			//供应者供应用的 随机数
int what;			//表示桌上有什么材料

//初始化offerYanCao互斥量，用于表示供应烟草和纸
Semaphore offerYanCaoAndZhi = CreateSemaphore(
	NULL,
	0,
	1,
	NULL
);

//初始化offerZhi互斥量，用于表示供应烟草和胶水
Semaphore offerYanCaoAndJiaoShui = CreateSemaphore(
	NULL,
	0,
	1,
	NULL
);

//初始化offerJiaoShui互斥量，用于表示供应纸和胶水
Semaphore offerZhiAndJiaoShui = CreateSemaphore(
	NULL,
	0,
	1,
	NULL
);

//初始化finish互斥量，用于表示吸烟完成
Semaphore finish = CreateSemaphore(
	NULL,
	0,
	1,
	NULL
);

DWORD WINAPI Producer(LPVOID);	//供应者线程函数
DWORD WINAPI Smoker1(LPVOID);	//1号吸烟者，拥有烟草
DWORD WINAPI Smoker2(LPVOID);	//2号吸烟者，拥有纸
DWORD WINAPI Smoker3(LPVOID);	//3号吸烟者，拥有胶水

VOID Put(int);					//供应者放材料
VOID Smoke();				//吸烟者吸烟


int main()
{

	HANDLE producer;
	HANDLE smoker1, smoker2, smoker3;

	
	producer = CreateThread(
		NULL,
		0,
		Producer,
		NULL,
		0,
		NULL
	);

	smoker1 = CreateThread(
		NULL,
		0,
		Smoker1,
		NULL,
		0,
		NULL
	);

	smoker2 = CreateThread(
		NULL,
		0,
		Smoker2,
		NULL,
		0,
		NULL
	);

	smoker3 = CreateThread(
		NULL,
		0,
		Smoker3,
		NULL,
		0,
		NULL
	);

	while (1)
	{
		WaitForSingleObject(producer, INFINITE);
		WaitForSingleObject(smoker1, INFINITE);
		WaitForSingleObject(smoker2, INFINITE);
		WaitForSingleObject(smoker3, INFINITE);
	}

	return 0;
}

VOID Put(int i) {
	if (i == YanCaoAndZhi) {
		what = YanCaoAndZhi;
		std::cout << "我是供应者，我现在要把【烟草】和【纸】放到桌上" << std::endl;
	}
	else if (i == YanCaoAndJiaoShui) {
		what = YanCaoAndJiaoShui;
		std::cout << "我是供应者，我现在要把【烟草】和【胶水】放到桌上" << std::endl;
	}
	else {
		what = ZhiAndJiaoShui;
		std::cout << "我是供应者，我现在要把【纸】和【胶水】放到桌上" << std::endl;
	}
}

VOID Smoke() {
	if (what == YanCaoAndZhi) {
		std::cout << "我是吸烟者【3】号，我拥有【胶水】，我现在从桌上拿走【烟草】和【纸】，我开始吸烟了"
			<< std::endl;
	}	
	else if (what == YanCaoAndJiaoShui) {
		std::cout << "我是吸烟者【2】号，我拥有【纸】，我现在从桌上拿走【烟草】和【胶水】，我开始吸烟了"
			<< std::endl;
	}
	else {
		std::cout << "我是吸烟者【1】号，我拥有【烟草】，我现在从桌上拿走【纸】和【胶水】，我开始吸烟了"
			<< std::endl;
	}
	what = 0;
}

DWORD WINAPI Producer(LPVOID) {
	while (1) {
		num++;							//要放入什么
		num = num % 3;					
		if (num == 0) {
			Put(YanCaoAndZhi);			//放入烟草和纸
			V(offerYanCaoAndZhi);		//唤醒拥有胶水的吸烟者
		}
		else if (num == 1) {
			Put(YanCaoAndJiaoShui);		//放入烟草和胶水
			V(offerYanCaoAndJiaoShui);	//唤醒拥有纸的吸烟者
			
		}
		else {
			Put(ZhiAndJiaoShui);		//放入纸和胶水
			V(offerZhiAndJiaoShui);		//唤醒拥有烟草的吸烟者
		}
		Sleep(1000);
		P(finish);						//是否有吸烟者吸完烟了？
	}
	return 0;
}

DWORD WINAPI Smoker1(LPVOID){			//拥有烟草的吸烟者
	while (1) {
		P(offerZhiAndJiaoShui);			//供应者是否放好了纸和胶水
		Smoke();						//拿走材料开始吸烟
		Sleep(1000);
		V(finish);
	}
	return 0;
}

DWORD WINAPI Smoker2(LPVOID) {			//拥有纸的吸烟者
	while (1) {
		P(offerYanCaoAndJiaoShui);		//供应者是否放好了烟草和胶水
		Smoke();						//拿走材料开始吸烟
		Sleep(1000);
		V(finish);
	}
	return 0;
}

DWORD WINAPI Smoker3(LPVOID) {			//拥有胶水的吸烟者
	while (1) {
		P(offerYanCaoAndZhi);			//供应者是否放好了烟草和纸
		Smoke();						//拿走 材料开始吸烟
		Sleep(1000);
		V(finish);
	}
	return 0;
}

运行效果：
在这里插入图片描述

一棵快乐的二叉树
关注
专栏目录
用C++实现生产者-消费者问题模型
qq_35160090的博客
06-06 1万+
用C++来实现生产者与消费者的模型，同时稍微讲解一点可能要讲解的地方。
生产者消费者的c++代码实现
11-29
计算机操作系统经典的生产者消费者问题c++高级语言的实现。编程入门必备。
c实现哲学家进餐问题。WINDOWS下。
Rh's blog
04-09 2160
c实现哲学家进餐问题。WINDOWS下。 // 解决哲学家就餐问题 // 每个哲学家可用一个线程来模拟。 // 设有5个哲学家，5只筷子，每个哲学家吃饭时间为一个随机值，哲学家吃饭后的思考时间也是一个随机值。 #include &lt;Windows.h&gt; #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;stdl...
C++ 生产者-消费者模式详细解析与代码实现
最新发布
shuai_258的博客
09-09 2732
生产者-消费者模式是一种通过缓冲区将生产者和消费者解耦的设计模式。生产者线程负责生成数据，而消费者线程负责消费数据。由于生产者和消费者的工作速度可能不同，因此缓冲区的存在使得它们可以独立运行。生产者-消费者模式是一种常见且有效的并发编程模型。在C++中，通过std::mutex和，我们可以轻松实现这一模式来协调多线程间的工作。本篇博客详细介绍了该模式的工作原理，并通过代码示例展示了它的实现。希望对你理解并应用生产者-消费者模式有所帮助。
生产者消费者问题 C++实现
热门推荐
陈浩的博客
06-29 3万+
生产者消费者问题 C++实现 知识准备 thread 介绍 成员类 成员函数 sleep_for 介绍 mutex 介绍 成员函数 unique_lock 介绍 成员函数 codition_variable 介绍 成员函数 代码示例 生产者消费者问题 C++实现 知识准备 thread 介绍 定位于头文件的class thread 表示...
[操作系统]生产者-消费者问题 C++实现
lsdqyz的博客
01-17 1087
生产者-消费者问题 C++实现
生产者消费者代码(C++版)
02-13
用Posix信号量, Posix互斥量, 解决生产者消费者问题(c++版)
C/C++实现生产者-消费者问题并发控制详解
生产者-消费者问题的模拟实现是一门操作系统课程的重要实践项目，旨在通过设计和编码来理解并应用进程并发控制和信号量机制。本设计目标包括以下几个关键知识点： 1. 设计目的： - 学习和巩固操作系统原理，特别是...
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
本文将深入探讨C++中的多线程通信方式，并结合经典的生产者-消费者模式来阐述其实现。 一、C++多线程基础 C++11引入了标准库`<thread>`，提供了对多线程的支持。创建线程的基本方法是通过`std::thread`类，如下所示...
生产者消费者问题c++实现
06-23
生产者消费者问题是多线程编程中的一个经典案例，它展示了如何通过线程间的协作来解决资源的同步和异步操作。在C++中，我们可以利用标准库中的互斥量（mutex）、条件变量（condition_variable）等工具来实现这个问题...
生产者-消费者问题（C++信号量实现）
lxx909546478的博客
10-27 4241
生产者-消费者问题是很经典的线程同步问题，这段代码给出的是多生产者、多消费者、有界缓冲区的一个C++实现。 常见的生产者消费者实现一般是Unix或Linux下的使用Pthread完成的，这里使用WINDOWS环境下的API实现。 #include<iostream> #include<queue> #include<Windows.h> #include<...
生产者消费者问题C/C++源程序
10-21
程序是在vc++2005上运行通过的，在vc6上运行有问题，不过只需要修改输出部分，应该还是可以的。 此外，在vc2005上运行时，由于WaitForMultiObjects函数只能等待64个线程，因此，只要生产者和消费者总数不超过64个就没问题，实际上，即使超过64个线程，通过修改WaitForMultiObjects函数等待对象个数为64，也是可以运行的。我测试了很多次，包括极端的情况（比如1000个生产者1个消费者或者相反的情形），没有问题。 如果需要帮助，可以和我联系。 操作系统中典型的同步问题，m个生产者，n个消费者链接在具有k个单位缓冲区的有界环形缓冲区上，生产者和消费者是并发线程，只要缓冲区未满，生产者线程就可以生产一件产品放入其中，只要缓冲区不空，消费者就可以从中取出一件产品消费。
多进程同步解决生产者消费者问题（c++源码）
01-08
用多进程同步方法解决生产者—消费者问题（c++源码） 1、每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容，当前指针位置和生产者/消费者进程的标识符。 2、生产者和消费者各有两个以上。 3、多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。
课程设计哲学家就餐问题（报告+代码）C++语言
09-07
设有五个哲学家,共用一张放有五把椅子的餐桌,每人坐在一把椅子上,桌子上有五个碗和五只筷子,每人两边各放一只筷子。哲学家们是交替思考和进餐,饥饿时便试图取其左右最靠近他的筷子。条件: (1) 只有拿到两只筷子时,哲学家才能吃饭。 (2) 如果筷子已被别人拿走,则必须等别人吃完之后才能拿到筷子。 (3) 任意一个哲学家在自己未拿到两只筷子吃饭前,不会放下手中拿到的筷子。
读者-写者问题C++程序
04-24
规则：多个读者和多个写者共同操作一个文件，当有一个写者在进行写操作时其他读者或写者都不能操作该文件，当有一个读者在进行读操作时，允许其他读者读，但不允许其他写者写。读者和写者都是每隔5秒操作一次，每次操作时间都是3秒。(此例为3个读者，2个写者)
读者与写者问题（VC源代码）
05-14
读者优先---读者线程，读者优先---写者线程，读者优先处理函数...
生产者跟消费者问题（C++实现）
肥宅Sean
06-26 6297
代码简述 T 表示有T个生产者。同时也有T个消费者。 然后每个生产者总共生产T个数据。 每个消费者总共消费T个数据。 N表示最大随机数大数值 那个信号量的实现，我是直接copy课件上的。 代码 #include &amp;lt;iostream&amp;gt; #include &amp;lt;string&amp;gt; #include &amp;lt;thread&amp;gt; #include &amp;lt;mutex&amp
读者写者问题c语言_经典生产者-消费者问题解析
weixin_26763955的博客
01-14 503
1.生产者-消费者问题生产者和消费者问题在现实系统中是很普遍的。例如在一个多媒体系统中，生产者编码视频帧，而消费者消费（解码）视频帧，缓冲区的目的就是减少视频流的抖动。又如在图形用户接口设计中，生产者检测到鼠标和键盘事件，并将其插入到缓冲区中。消费者以某种基于优先级的方式从缓冲区中取出这些事件并显示在屏幕上。生产者和消费者模式共享一个有n个槽位的有限缓冲区。生产者反复地生成新的item，并将它插入...
C++实现生产者消费者
YFaris的博客
10-22 3185
为应对系统的通信上消息收发的高耦合度，在接受和发送消息后设计一个缓存队列，并使用多线程生产者-消费者来进行收发解耦。避免通信上的拥堵情况。 利用C++内置函数实现生产者-消费者功能： private: std::deque<T> queue_; //缓存队列 size_t size_limit_; //缓存队列大小的限制 std::mutex lock_; //互斥锁 std::condition_variable empty_, full_; //并发条件变量类 s
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一棵快乐的二叉树

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值