哲学家干饭问题 C++

最新推荐文章于 2024-05-11 23:30:22 发布
最新推荐文章于 2024-05-11 23:30:22 发布
阅读量1k 收藏 5
点赞数
分类专栏： C++ 多线程 C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42896106/article/details/126917511
版权

哲学家干饭问题 C++

img

哲学家就餐问题可以这样表述，假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌上有五碗意大利面，每位哲学家之间各有一支餐叉。因为用一支餐叉很难吃到意大利面，所以假设哲学家必须用两支餐叉吃东西。他们只能使用自己左右手边的那两支餐叉。哲学家就餐问题有时也用米饭和五根筷子而不是意大利面和餐叉来描述，因为吃米饭必须用两根筷子。

这个问题不考虑意大利面有多少，也不考虑哲学家的胃有多大。假设两者都是无限大。

问题在于如何设计一套规则，使得在哲学家们在完全不交谈，也就是无法知道其他人可能在什么时候要吃饭或者思考的情况下，可以在这两种状态下永远交替下去。

使用忙等待获取资源

#include <iostream>
#include <thread>
#include <atomic>
#include <atomic>
#include <format>
#include <list>
#include <mutex>
#include <shared_mutex>
#include <execution>
#include <map>
#include <future>
#include <future>
#include <iostream>
#include <thread>
#include <utility>
#include <random>


using namespace std;

std::random_device rd_device;
std::mt19937_64 rd_engine(rd_device());

//生成随机数
int generate_random_number(int min, int max)
{
	std::uniform_int_distribution<int> dist(min, max);
	return dist(rd_engine);
}

void lock(std::atomic<int>& resource_number)
{
	while (resource_number);
	//忙等待
	resource_number = 1;
}


void unlock(std::atomic<int>& resource_number)
{
	resource_number = 0;
}

void feast_think(int n, std::atomic<int>& a, std::atomic<int>& b)
{
	while (true)
	{
		int duration = generate_random_number(1000, 1500);
		std::cout << std::format("{} 思考{}ms \n", n, duration);
		std::this_thread::sleep_for(std::chrono::milliseconds(duration)); // 思考

		lock(a);
		std::cout << std::format("{} 获取a筷子\n", n);
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));

		lock(b);
		std::cout << std::format("{} 获取b筷子\n", n);

		duration = generate_random_number(1000, 1500);
		std::cout << std::format("{} 干饭时间：{} ms \n", n, duration);

		std::this_thread::sleep_for(std::chrono::milliseconds(duration));

		unlock(b);
		unlock(a);
		std::cout << "\n\n";
	}
}

int main(int argc, char* argv[])
{
	std::atomic<int> m1{0}, m2{0}, m3{0}, m4{0};

	std::thread t1{[&]() { feast_think(1, m1, m2); }};
	std::thread t2{[&]() { feast_think(2, m2, m3); }};
	std::thread t3{[&]() { feast_think(3, m3, m4); }};
	std::thread t4{[&]() { feast_think(4, m1, m4); }};

	t1.join();
	t2.join();
	t3.join();
	t4.join();
}

image-20220918133938698

我们使用lock|unlock获取和释放资源， 但是在这之间，线程调度可能会导致线程切换，出现一些难以发现的问题

优化使用忙等待获取资源

std::random_device rd_device;
std::mt19937_64 rd_engine(rd_device());

//生成随机数
int generate_random_number(int min, int max)
{
	std::uniform_int_distribution<int> dist(min, max);
	return dist(rd_engine);
}

void lock(std::atomic_flag& resource_flag)
{
	while (resource_flag.test_and_set());
	//忙等待
}


void unlock(std::atomic_flag& resource_flag)
{
	resource_flag.clear();
}

void feast_think(int n, std::atomic_flag& a, std::atomic_flag& b)
{
	while (true)
	{
		int duration = generate_random_number(100, 200);
		std::cout << std::format("{} 思考{}ms \n", n, duration);
		std::this_thread::sleep_for(std::chrono::milliseconds(duration)); // 思考

		lock(a);
		std::cout << std::format("{} 获取a筷子\n", n);
		std::this_thread::sleep_for(std::chrono::milliseconds(100));

		lock(b);
		std::cout << std::format("{} 获取b筷子\n", n);

		duration = generate_random_number(100, 200);
		std::cout << std::format("{} 干饭时间：{} ms \n", n, duration);

		std::this_thread::sleep_for(std::chrono::milliseconds(duration));

		unlock(b);
		unlock(a);
		std::cout << "\n\n";
	}
}

int main(int argc, char* argv[])
{
	std::atomic_flag m1, m2, m3, m4;

	std::thread t1{[&]() { feast_think(1, m1, m2); }};
	std::thread t2{[&]() { feast_think(2, m2, m3); }};
	std::thread t3{[&]() { feast_think(3, m3, m4); }};
	std::thread t4{[&]() { feast_think(4, m1, m4); }};

	t1.join();
	t2.join();
	t3.join();
	t4.join();
}

lock中使用循环浪费了大量的CPU，可以使用sleep_for短暂的暂停循环来节约CPU

image-20220918134956329

降低CPU占用率

添加

while (resource_flag.test_and_set())
	{
		std::this_thread::sleep_for(std::chrono::milliseconds(8));
	}

image-20220918135104626

CPU占用几乎为零

使用std::mutex

关于自旋锁与互斥量的区别：Waiting Thread - an overview | ScienceDirect Topics

简单说：自旋锁等待另一个线程，互斥量等待系统调度，所以互斥量不会占用大量的CPU周期，自旋锁会占用大量的CPU周期

void feast_think(int n, std::mutex& a, std::mutex& b)
{
	while (true)
	{
		int duration = generate_random_number(100, 200);
		std::cout << std::format("{} 思考{}ms \n", n, duration);
		std::this_thread::sleep_for(std::chrono::milliseconds(duration)); // 思考

		a.lock();
		std::cout << std::format("{} 获取a筷子\n", n);
		std::this_thread::sleep_for(std::chrono::milliseconds(100));

		b.lock();
		std::cout << std::format("{} 获取b筷子\n", n);

		duration = generate_random_number(100, 200);
		std::cout << std::format("{} 干饭时间：{} ms \n", n, duration);

		std::this_thread::sleep_for(std::chrono::milliseconds(duration));

		b.unlock();
		a.unlock();
		std::cout << "\n\n";
	}
}

int main(int argc, char* argv[])
{
	std::mutex m1, m2, m3, m4;

	std::thread t1{[&]() { feast_think(1, m1, m2); }};
	std::thread t2{[&]() { feast_think(2, m2, m3); }};
	std::thread t3{[&]() { feast_think(3, m3, m4); }};
	std::thread t4{[&]() { feast_think(4, m1, m4); }};

	t1.join();
	t2.join();
	t3.join();
	t4.join();
}

使用std::unique_lock以及std::defer_lock标志

我们可以使用一步操作，同时获取两个互斥量，这样就不会有死锁的风险

为了保证输出同步，添加一个mutex mo

using namespace std;

std::random_device rd_device;
std::mt19937_64 rd_engine(rd_device());

//生成随机数
int generate_random_number(int min, int max)
{
	std::uniform_int_distribution<int> dist(min, max);
	return dist(rd_engine);
}

std::mutex mo;

void feast_think(int n, std::mutex& a, std::mutex& b)
{
	while (true)
	{
		int duration = generate_random_number(1000, 2000);

		{
			std::lock_guard<std::mutex> g(mo);
			std::cout << std::format("{} 思考{}ms \n", n, duration);
		}

		std::this_thread::sleep_for(std::chrono::milliseconds(duration)); // 思考

		std::unique_lock<std::mutex> ga(a, std::defer_lock);

		{
			std::lock_guard<std::mutex> g(mo);
			std::cout << std::format("{} 获取a筷子\n", n);
		}


		std::this_thread::sleep_for(std::chrono::milliseconds(1000));

		std::unique_lock<std::mutex> gb(b, std::defer_lock);
		std::lock(ga, gb);
		{
			std::lock_guard<std::mutex> g(mo);
			std::cout << std::format("{} 获取b筷子\n", n);
		}

		duration = generate_random_number(1000, 2000);
		{
			std::lock_guard<std::mutex> g(mo);
			std::cout << std::format("{} 干饭时间：{} ms \n", n, duration);
		}

		std::this_thread::sleep_for(std::chrono::milliseconds(duration));


		std::cout << "\n\n";
	}
}

int main(int argc, char* argv[])
{
	std::mutex m1, m2, m3, m4;

	std::thread t1{[&]() { feast_think(1, m1, m2); }};
	std::thread t2{[&]() { feast_think(2, m2, m3); }};
	std::thread t3{[&]() { feast_think(3, m3, m4); }};
	std::thread t4{[&]() { feast_think(4, m1, m4); }};

	t1.join();
	t2.join();
	t3.join();
	t4.join();
}
繁星意未平
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程经典哲学家就餐问题 C++11 3种实现
Dave_lzw的博客
12-09 1713
leetcode1226. 哲学家就餐问题核心是 避免死锁 同时拿起左右叉子 class DiningPhilosophers { public: DiningPhilosophers() { } void wantsToEat(int philosopher, function<void()> pickLeftFork, function<void()>
C++哲学家吃饭问题
ReDreamme的博客
06-02 1138
利用C++11对哲学家吃饭问题进行超简单实现
【C++学习笔记】多线程编程——哲学家就餐问题
Siro_sama的博客
05-11 204
预防死锁的思路是破坏保持并请求条件，不获得两个叉子就不会占有叉子。一个能在控制台实时打印当前状态的哲学家就餐。
C++ 线程之哲学家就餐问题
weixin_42333471的博客
03-28 1000
转自：C++标准线程库之哲学家就餐问题 #include <iostream> #include <exception> #include <mutex> #include <vector> #include <string> #include <algorithm> #include <functional> #...
经典同步问题之哲学家就餐
qq_43727529的博客
06-18 1343
五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五只筷子，他们的生活方式是交替的进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到左右两只筷子时才能进餐，进餐完毕，放下筷子继续思考。上述程序中互斥量的作用在于，只要有一个哲学家进入了临界区，也就是准备拿叉子时，其他哲学家是互斥不可访问临界区的，这又当这个哲学家吃完了退出临界区后，其他哲学家才可以拿叉子进餐。上面的程序，在P操作时，根据哲学家的编号不同，拿起左右两边叉子的顺序不同。
操作系统 哲学家进餐问题
ljk的博客
04-04 889
操作系统 哲学家进餐问题
卡尔曼滤波KF算法C++实现
11-06
在常加速度模型下，卡尔曼滤波通常用于处理物体在有加速度的运动中的状态估计问题。这个模型假设物体的加速度是恒定的，可以通过连续两次位置差的平方除以时间间隔来估算。在实际应用中，这种模型常用于车辆定位、...
干饭小宝贝专属1.0.html
05-10
网页转盘抽奖
今日干饭背诵Chap9应用层（1.8）1
08-03
【网络应用层详解】 网络应用层是TCP/IP协议栈的最高层，负责处理特定的应用程序需求，如网页浏览、电子邮件、文件传输等。这一层的主要任务是定义应用程序如何利用网络来实现它们的功能，同时提供了进程间通信...
干饭鸭外卖小程序，对标美团，饿了么
最新发布
06-29
对标美团，饿了么，可收款，技术支持微信号：lyj1771839980
干饭王陆文龙的网页设计与制作的作业.zip
10-22
在干饭王陆文龙的课程作业中，我们可以预期他将学习到网页设计的基本原理，如布局设计（例如F型布局、Z型布局）、色彩理论（颜色搭配、对比度、色调等）、字体选择（易读性、视觉层次）以及网页元素的对齐方式等。...
哲学家就餐问题源程序
12-21
关于5个哲学家就餐线程同步问题的解决方法 此方法对左右手刀叉实行控制，防止了死锁，实现了线程的同步 注意5个以上的哲学家亦可用此方法解决
哲学家进餐问题代码C++代码编写API动态显示
05-09
哲学家进餐问题代码动态描述，API显示，C++语言编写
多进程/线程编程：哲学家问题
07-05
多进程/线程编程：哲学家问题。  设置进程/线程，描述哲学家 ；  随机启动哲学家 ；  显示进程/线程执行状态；  随着线程的执行，更新显示；  编写正确的哲学家程序，设法延迟线程的执行，使之出现死锁；  编写正确的哲学家程序，保证不出现死锁；
课程设计哲学家就餐问题（报告+代码）C++语言
09-07
设有五个哲学家,共用一张放有五把椅子的餐桌,每人坐在一把椅子上,桌子上有五个碗和五只筷子,每人两边各放一只筷子。哲学家们是交替思考和进餐,饥饿时便试图取其左右最靠近他的筷子。条件: (1) 只有拿到两只筷子时,哲学家才能吃饭。 (2) 如果筷子已被别人拿走,则必须等别人吃完之后才能拿到筷子。 (3) 任意一个哲学家在自己未拿到两只筷子吃饭前,不会放下手中拿到的筷子。
哲学家就餐问题（条件变量）
LUCAS004的博客
09-12 719
        1965年，著名计算机科学家艾兹格·迪科斯彻，提出并解决了一个他称之为哲学家就餐的同步问题。         从那时起，每个发明同步原语的人，都希望通过解决哲学家就餐问题来展示其同步原语的精妙之处。 这个问题可以简单地描述如下：         五个哲学家
哲学家算法c++线程实现
king9666的博客
10-21 618
哲学家算法c++线程实现 调用了很多STL函数 标记了注释 具体实现了五个哲学家就餐的问题 当然 人数可以根据需求改变 #include <windows.h> #include <process.h> #include "iostream" using namespace std; const unsigned int N= 5; //number of ph...
多线程同步——哲学家吃饭问题
凛冬烈焰的博客
06-05 8145
最近在学习多线程编程（WIN32API下和C++11标准），学习过程中想起了在学操作系统的时候出现过的“哲学家吃饭问题”，当时听得云里雾里的，理解并不算透彻。恰好最近在学习多线程同步的知识，恰好可以利用最近所学模拟一下这个过程。一、问题描述二、问题分析哲学家就餐问题需要协调考虑两个问题：1、不能让某个哲学家饿死；2、要尽量提升吃饭的效率，也就是同一时间尽量让多一些哲学家吃饭（最多同时两个）。我们考...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值