哲学家进餐问题

最新推荐文章于 2024-10-01 00:00:00 发布
最新推荐文章于 2024-10-01 00:00:00 发布
阅读量1.2k 收藏 18
点赞数 1
分类专栏： 操作系统 文章标签： 考研 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oncruise/article/details/131530249
版权

        本篇文章我们使用C++探讨一下哲学家进餐问题. 

         如图为5名哲学家, 桌子上有五根筷子和五碗饭, 每个哲学家都只做两件事: 吃饭和思考. 哲学家思考不需要额外的资源, 只需要动用他们的大脑; 但吃饭不同, 吃饭需要拿起两根筷子才能吃饭. 我们还是先从最简单的情况写出代码, 假设哲学家吃饭不需要筷子, 代码如下: 

#include <iostream>
#include <thread>
#include <windows.h>
#include <condition_variable>
#include <mutex>
#include <chrono>

/// <summary>
/// 哲学家函数
/// </summary>
void philosopher_fun(int index) {
    while (true)
    {
        printf("哲学家%d进餐\n", index);
        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒

        printf("哲学家%d思考\n", index);
        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒
    }
}

int main()
{
    std::thread philosopher_thread0(philosopher_fun, 0);    //哲学家线程0
    std::thread philosopher_thread1(philosopher_fun, 1);    //哲学家线程1
    std::thread philosopher_thread2(philosopher_fun, 2);    //哲学家线程2
    std::thread philosopher_thread3(philosopher_fun, 3);    //哲学家线程3
    std::thread philosopher_thread4(philosopher_fun, 4);    //哲学家线程4

    philosopher_thread0.join();    //等待线程结束
    philosopher_thread1.join();    
    philosopher_thread2.join();    
    philosopher_thread3.join();    
    philosopher_thread4.join();    

    return 0;
}

代码1: 哲学家进餐(不需要筷子即可进餐)

        现在我们需要给进餐加上一些限制, 只有当哲学家把左右两边的筷子都拿起来时, 才能进餐, 进餐后归还筷子. 很显然, 筷子左右两边的哲学家对这根筷子是互斥访问的,  因此五根筷子的信号量初始值均为1, 这里我们可以用一个长度为5的数组chopstick[]来管理这些筷子, 数组中的元素初始值均为1, 每当哲学家 i 进餐之前, 就去申请他左右两边的筷子, 先申请左边的筷子chopstick[ i ], 若chopstick[ i ] 为1, 则成功申请, 若chopstick[ i ] 为0, 则阻塞当前线程; 再申请右边的筷子chopstick[(i + 1) % 5], 若chopstick[(i + 1) % 5]为1, 则申请成功, 若chopstick[(i + 1) % 5]为0, 则阻塞当前线程. 进餐之后, 先归还左边筷子, 再归还右边筷子. 代码如下: 

#include <iostream>
#include <thread>
#include <windows.h>
#include <condition_variable>
#include <mutex>
#include <chrono>

/// <summary>
/// 筷子数组
/// </summary>
int chopstick[5] = { 1, 1, 1, 1, 1 };

/// <summary>
/// 定义一个长度为 5 的 mutex 数组
/// </summary>
std::mutex mutexArr[5];

std::condition_variable philosopher_cv;    //条件变量, 哲学家线程的管理队列

/// <summary>
/// 哲学家函数
/// </summary>
void philosopher_fun(int index) {
    while (true)
    {
        //申请左手边的筷子
        std::unique_lock<std::mutex> left_lock(mutexArr[index]);
        philosopher_cv.wait(left_lock, [&]() { return chopstick[index] == 1; });     //若左边的筷子的数量为1, 则当前线程可以继续执行
        chopstick[index] = 0;

        //申请右手边的筷子
        std::unique_lock<std::mutex> right_lock(mutexArr[(index + 1) % 5]);
        philosopher_cv.wait(right_lock, [&]() { return chopstick[(index + 1) % 5] == 1; });     //若右边的筷子数量为1, 则当前线程可以继续执行
        chopstick[(index + 1) % 5] = 0;

        printf("哲学家%d进餐\n", index);

        //归还左手边的筷子
        chopstick[index] = 1;
        philosopher_cv.notify_all();

        //归还右手边的筷子
        chopstick[(index + 1) % 5] = 1;
        philosopher_cv.notify_all();

        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒

        printf("哲学家%d思考\n", index);
        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒
    }
}

int main()
{
    std::thread philosopher_thread0(philosopher_fun, 0);    //哲学家线程0
    std::thread philosopher_thread1(philosopher_fun, 1);    //哲学家线程1
    std::thread philosopher_thread2(philosopher_fun, 2);    //哲学家线程2
    std::thread philosopher_thread3(philosopher_fun, 3);    //哲学家线程3
    std::thread philosopher_thread4(philosopher_fun, 4);    //哲学家线程4

    philosopher_thread0.join();    //等待线程结束
    philosopher_thread1.join();    
    philosopher_thread2.join();    
    philosopher_thread3.join();    
    philosopher_thread4.join();    

    return 0;
}

代码2: 哲学家进餐(需要筷子方可进餐)

        读者可自行尝试运行这段代码, 会发现这段代码的打印输出过了一段时间就停止了, 下面我们就分析一下这种现象产生的原因. 试想一下, 当线程0顺利执行到chopstick[index] = 0; 这句代码之后, 就转而去执行线程1的代码, 线程1也执行到chopstick[index] = 0; 这句代码之后, 就转而去执行线程2的代码; 线程2执行到这一句就转而执行线程3, 线程3执行到这一句就转而执行线程4. 这下每个哲学家都占有了左手边的筷子, 当他们继续执行下去时, 需要申请右手边的筷子, 但自己右手边的筷子被自己右手边的哲学家占有, 所以只能一直等待. 我们称这种现象为死锁. 

        为防止死锁发生, 我们可对哲学家线程施加一些限制条件. 比如: ①仅当一名哲学家左右两边的筷子都可用时，才允许他抓起筷子; ②至多允许4名哲学家同时进餐; ③对哲学家顺序编号, 要求奇数号哲学家先拿左边的筷子, 然后拿右边的筷子, 而偶数号哲学家刚好相反. 这里我们采用第①种方法, 把拿起左边筷子和拿起右边筷子变成不能被打断的操作即可. 代码如下: 

#include <iostream>
#include <thread>
#include <windows.h>
#include <condition_variable>
#include <mutex>
#include <chrono>

/// <summary>
/// 筷子数组
/// </summary>
int chopstick[5] = { 1, 1, 1, 1, 1 };

/// <summary>
/// 定义一个长度为 5 的 mutex 数组
/// </summary>
std::mutex mutexArr[5];

std::condition_variable philosopher_cv;    //条件变量, 哲学家线程的管理队列

/// <summary>
/// 拿起筷子的互斥量, 初值为1
/// </summary>
int get_cpstk_mutex = 1;

/// <summary>
/// 拿起筷子的互斥信号量
/// </summary>
std::mutex get_cpstk_mtx;

/// <summary>
/// 哲学家函数
/// </summary>
void philosopher_fun(int index) {
    while (true)
    {
        std::unique_lock<std::mutex> lock(get_cpstk_mtx);
        philosopher_cv.wait(lock, []() {return get_cpstk_mutex = 1; });
        get_cpstk_mutex = 0;

        //申请左手边的筷子
        std::unique_lock<std::mutex> left_lock(mutexArr[index]);
        philosopher_cv.wait(left_lock, [&]() { return chopstick[index] == 1; });     //若左边的筷子的数量为1, 则当前线程可以继续执行
        chopstick[index] = 0;

        //申请右手边的筷子
        std::unique_lock<std::mutex> right_lock(mutexArr[(index + 1) % 5]);
        philosopher_cv.wait(right_lock, [&]() { return chopstick[(index + 1) % 5] == 1; });     //若右边的筷子数量为1, 则当前线程可以继续执行
        chopstick[(index + 1) % 5] = 0;

        get_cpstk_mutex = 1;
        philosopher_cv.notify_all();

        printf("哲学家%d进餐\n", index);

        //归还左手边的筷子
        chopstick[index] = 1;
        philosopher_cv.notify_all();

        //归还右手边的筷子
        chopstick[(index + 1) % 5] = 1;
        philosopher_cv.notify_all();

        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒

        printf("哲学家%d思考\n", index);
        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒
    }
}

int main()
{
    std::thread philosopher_thread0(philosopher_fun, 0);    //哲学家线程0
    std::thread philosopher_thread1(philosopher_fun, 1);    //哲学家线程1
    std::thread philosopher_thread2(philosopher_fun, 2);    //哲学家线程2
    std::thread philosopher_thread3(philosopher_fun, 3);    //哲学家线程3
    std::thread philosopher_thread4(philosopher_fun, 4);    //哲学家线程4

    philosopher_thread0.join();    //等待线程结束
    philosopher_thread1.join();
    philosopher_thread2.join();
    philosopher_thread3.join();
    philosopher_thread4.join();

    return 0;
}

代码3: 哲学家进餐(拿起两边筷子的操作不能被打断)

        最终代码如下: 

#include <iostream>
#include <thread>
#include <windows.h>
#include <condition_variable>
#include <mutex>
#include <chrono>

/// <summary>
/// 筷子数组
/// </summary>
int chopstick[5] = { 1, 1, 1, 1, 1 };

/// <summary>
/// 定义一个长度为 5 的 mutex 数组
/// </summary>
std::mutex mutexArr[5];

std::condition_variable philosopher_cv;    //条件变量, 哲学家线程的管理队列

/// <summary>
/// 拿起筷子的互斥量, 初值为1
/// </summary>
int get_cpstk_mutex = 1;

/// <summary>
/// 拿起筷子的互斥信号量
/// </summary>
std::mutex get_cpstk_mtx;

/// <summary>
/// 哲学家函数
/// </summary>
void philosopher_fun(int index) {
    while (true)
    {
        //P(get_cpstk_mtx)
        std::unique_lock<std::mutex> lock(get_cpstk_mtx);
        philosopher_cv.wait(lock, []() {return get_cpstk_mutex = 1; });
        get_cpstk_mutex = 0;

        //P(mutexArr[index])
        std::unique_lock<std::mutex> left_lock(mutexArr[index]);
        philosopher_cv.wait(left_lock, [&]() { return chopstick[index] == 1; });     //若左边的筷子的数量为1, 则当前线程可以继续执行
        chopstick[index] = 0;

        //P(mutexArr[(index + 1) % 5])
        std::unique_lock<std::mutex> right_lock(mutexArr[(index + 1) % 5]);
        philosopher_cv.wait(right_lock, [&]() { return chopstick[(index + 1) % 5] == 1; });     //若右边的筷子数量为1, 则当前线程可以继续执行
        chopstick[(index + 1) % 5] = 0;

        //V(get_cpstk_mtx)
        get_cpstk_mutex = 1;
        philosopher_cv.notify_all();

        //eating()
        printf("哲学家%d进餐\n", index);

        //V(mutexArr[index])
        chopstick[index] = 1;
        philosopher_cv.notify_all();

        //V(mutexArr[(index + 1) % 5])
        chopstick[(index + 1) % 5] = 1;
        philosopher_cv.notify_all();

        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒

        //thinking()
        printf("哲学家%d思考\n", index);
        std::this_thread::sleep_for(std::chrono::seconds(1));   //当前线程阻塞1秒
    }
}

int main()
{
    std::thread philosopher_thread0(philosopher_fun, 0);    //哲学家线程0
    std::thread philosopher_thread1(philosopher_fun, 1);    //哲学家线程1
    std::thread philosopher_thread2(philosopher_fun, 2);    //哲学家线程2
    std::thread philosopher_thread3(philosopher_fun, 3);    //哲学家线程3
    std::thread philosopher_thread4(philosopher_fun, 4);    //哲学家线程4

    philosopher_thread0.join();    //等待线程结束
    philosopher_thread1.join();
    philosopher_thread2.join();
    philosopher_thread3.join();
    philosopher_thread4.join();

    return 0;
}

代码3: 哲学家进餐(最终代码)

        另外两种解决死锁的方法读者可自行了解. 

oncruise
关注
专栏目录
哲学家进餐问题的代码
05-05
有三个.cpp文件，代码是我亲手写的，都可以运行，这个代码包含有3种方式避免死锁的方法，一个是允许四个哲学家同时进餐，第二个是一下子就拿两根筷子，否则不拿，第三个就是奇数哲学家先拿左边的筷子，偶数哲学家拿右边的筷子
操作系统：哲学家进餐问题（p,v操作实现互斥与同步）
03-27
分析哲学家进餐问题，p,v操作实现互斥与同步，分析记录性信号量的不足，并指出给改进方法 方法一：最多允许4人同时进餐； 方法二：分奇偶数进餐，以及AND型信号量解决该问题。 （免费下载，无需积分）
C语言实现 操作系统 经典的进程同步问题（2）
最新发布
2301_79046256的博客
10-01 1092
哲学家进餐问题是一个经典的同步问题，涉及多个哲学家试图同时用餐，但每个哲学家左右两边只有一把叉子。为了避免死锁和饥饿，可以使用记录型信号量（也称为计数信号量）来管理叉子的使用。1、利用记录型信号量解决哲学家进餐问题（1）信号量初始化：使用sem_init初始化每把叉子的信号量，初始值为1，表示可用。哲学家线程：每个哲学家线程尝试拿起左边的叉子（），如果失败则继续思考。如果成功拿起左边的叉子，再尝试拿起右边的叉子。如果失败，则放下左边的叉子并继续思考。
操作系统：哲学家就餐问题的奇偶解决方法（含代码）
俊夫小瞳的博客
06-20 5825
1. 原理说明0、1、2、3、4为哲学家 ⓪、①、②、③、④为筷子哲学家就餐问题是一种一个进程需要两个临界资源的问题。 如果每位哲学家都先拿自己左边的筷子，那么此时没有冲突，每位哲学家都可以拿到自己左边的筷子。 但是接下来每位哲学家都去拿自己右边的筷子时，右边的筷子已经被右边的哲学家拿走了，那么所有的哲学家就只能等着自己右边的哲学家把其左边的筷子放下才能继续就餐，因此整个程序会陷入永久阻塞。这种每个进程都在等待其他进程释放资源或者是等待其他进程给出所需数据而无限期陷入僵持的状态，称为死锁。为了解决哲学家就餐
哲学家进餐问题——经典进程同步问题
weixin_53236070的博客
03-21 1万+
哲学家进餐问题——经典进程同步问题
哲学家就餐问题（死锁）
Qynwang的博客
06-03 905
本文主要讲述死锁的一个经典案例—哲学家就餐问题，并对该问题进行修复。
操作系统：哲学家就餐问题
qq_43789604的博客
11-01 3613
使用C语言实现哲学家就餐问题，并以破除依赖的方法解决了死锁问题。
哲学家就餐问题（java全代码)
weixin_60401853的博客
11-23 991
java实现哲学家就餐问题
java实现哲学家进餐问题
05-21
有五个哲学家，他们的生活方式是交替地进行思考和进餐。他们共用一张圆桌，分别坐在五张椅子上。 在圆桌上有五个碗和五把叉子，平时...哲学家进餐问题可看作是并发进程并发执行时处理共享资源的一个有代表性的问题。
操作系统课程设计哲学家进餐问题报告
01-04
操作系统课程设计中的“哲学家进餐问题”是一个经典的并发控制问题，旨在模拟多个进程竞争共享资源的情景。在这个问题中，哲学家们坐在一张圆桌旁，每人在思考间隙需要拿起左右两边的刀叉来进餐。为了防止死锁，即...
哲学家进餐问题.zip
07-29
在这个"哲学家进餐问题.zip"压缩包中，包含了三个关键文件：一个C++源代码文件（哲学家进餐问题.cpp）、一个详细实现文档（哲学家进餐问题.doc）和一个可执行文件（哲学家进餐问题.exe）。.vscode文件夹可能是开发...
哲学家进餐问题多线程演示代码.zip
05-15
《哲学家进餐问题与C/C++多线程同步实践》 在计算机科学领域，多线程编程是一项关键技能，特别是在解决并发问题时。这里我们关注的是一个经典的并发问题——哲学家进餐问题（Dining Philosophers Problem）。该问题...
哲学家进餐问题代码
05-27
哲学家进餐问题代码
哲学家进餐问题【VS可视化；C#；操作系统作业】
10-08
哲学家进餐问题是一个经典的操作系统并发控制问题，由计算机科学家Edsger W. Dijkstra提出，用以探讨多线程环境中的死锁问题。在这个问题中，有五个哲学家围坐在一张圆桌旁，他们既思考又进餐。每个哲学家都有一个...
模拟哲学家进餐问题.rar
06-19
"模拟哲学家进餐问题"是一个经典的多线程并发控制问题，源于计算机科学与操作系统设计领域。这个问题由美国计算机科学家Edsger W. Dijkstra在20世纪60年代提出，用于探讨和解决资源竞争与死锁的问题。在这个场景中，...
经典同步问题之哲学家就餐
qq_43727529的博客
06-18 1607
五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五只筷子，他们的生活方式是交替的进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到左右两只筷子时才能进餐，进餐完毕，放下筷子继续思考。上述程序中互斥量的作用在于，只要有一个哲学家进入了临界区，也就是准备拿叉子时，其他哲学家是互斥不可访问临界区的，这又当这个哲学家吃完了退出临界区后，其他哲学家才可以拿叉子进餐。上面的程序，在P操作时，根据哲学家的编号不同，拿起左右两边叉子的顺序不同。
哲学家就餐问题C语言实现（涉及多线程、信号量等）
热门推荐
qq_44806305的博客
06-21 1万+
哲学家就餐问题C语言实现（涉及多线程、信号量等）1、实验原理2、实验内容3、代码部分3.1 重要代码展示3.2 源码3.3 运行结果展示 1、实验原理   由Dijkstra提出并解决的哲学家进餐问题(The Dinning Philosophers Problem)是典型的同步问题。该问题是描述有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五只筷子，他们的生活方式是交替地进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。
操作系统经典问题之哲学家就餐算法
m0_43405302的博客
12-21 6093
一、问题描述 一群哲学家围绕一个圆桌思考问题，圆桌上摆满了美食。在每个哲学家两边各有一个筷子，两个哲学家之间只有一个筷子，只有当哲学家拿到左右两边的筷子才可以吃饭，当哲学家吃饱了就会将筷子放下来接着进行思考。为了避免哲学家饿死，就诞生出哲学家就餐的问题。 二、解决思路（1） 1、思路分析 为了避免哲学家饿死，我们现在给哲学家定另一个规矩：最后一个哲学家比较扛饿，他的肚子最大，一时半会儿饿不死，他最后才可以吃。假设有n个哲学家，我们通过设置一个信号初始值n-1。 2、伪代码实现 semaphore count
哲学家进餐问题3种代码 c
09-04
哲学家进餐问题涉及到一个经典的多线程同步问题，即多个哲学家围坐在一张圆桌旁，每个哲学家面前放着一碗饭和一只叉子。哲学家思考和进餐，思考时需要两只叉子，进餐时需要拿起两只叉子。问题的关键在于如何保证每个哲学家都能得到他所需要的两只叉子而不产生死锁。 以下是三种解决哲学家进餐问题的代码示例： 代码1： 1. 创建一个共享的锁数组，每个元素代表一只叉子； 2. 每个哲学家线程首先尝试获取自己左边的叉子，然后再尝试获取自己右边的叉子； 3. 若成功获取到两只叉子，则可以进餐，进餐完成后释放两只叉子； 4. 若未能同时获取到两只叉子，则释放已经获取到的叉子，进入等待状态，等待其他线程释放叉子。 代码2： 1. 创建一个共享的信号量数组，每个元素代表一只叉子； 2. 每个哲学家线程首先尝试获取自己左边的叉子，然后再尝试获取自己右边的叉子； 3. 若成功获取到两只叉子，则可以进餐，进餐完成后释放两只叉子； 4. 若未能同时获取到两只叉子，则释放已经获取到的叉子，进入等待状态，等待其他线程释放叉子。 代码3： 1. 创建一个共享的计数器，代表可用的叉子数量； 2. 每个哲学家线程首先尝试获取自己左边的叉子，然后再尝试获取自己右边的叉子； 3. 若成功获取到两只叉子，则可以进餐，进餐完成后释放两只叉子，并将计数器加1； 4. 若未能同时获取到两只叉子，则释放已经获取到的叉子，进入等待状态，等待其他线程释放叉子并将计数器加1。 这三种代码的目标都是确保每个哲学家都能获取到所需要的两只叉子，避免死锁情况的发生。具体使用哪种代码取决于实际需求和环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值