Linux C哲学家吃饭问题

最新推荐文章于 2024-03-27 12:14:40 发布
最新推荐文章于 2024-03-27 12:14:40 发布
阅读量994 收藏 16
点赞数 6
分类专栏： Linux C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53012351/article/details/117233666
版权

哲学家吃饭问题

哲学家问题

有五个哲学家绕着圆桌坐，每个哲学家面前有一盘面，两人之间有一支筷子，这样每个哲学家左右各有一支筷子。哲学家有2个状态，思考或者拿起筷子吃饭。如果哲学家拿到一只筷子，不能吃饭，直到拿到2只才能吃饭，并且一次只能拿起身边的一支筷子。一旦拿起便不会放下筷子直到把饭吃完，此时才把这双筷子放回原处。如果，很不幸地，每个哲学家拿起他或她左边的筷子，那么就没有人可以吃到饭了（死锁）。哲学家进餐问题是一个多线程运用的经典例子，涉及到线程同步/互斥，临界区访问问题以及死锁问题。我们要做的就是防止死锁。

线程中的信号量

这里的信号量和我另一篇博客中进程间的通信的博客里的信号量是不同的，区别可以参考我找到的一篇博客进程的信号量和线程的信号量。
信号量是一个计数器，可以用来控制多个进程或线程对共享资源的访问。它常作为一种锁机制，防止某进程或线程在访问共享资源时，其他进程或线程也在访问，因此主要作为进程间或同一进程间不同线程之间的同步机制。当信号量大于0时表示可以使用的资源数量，小于0时表示等待使用资源的进程或线程个数。信号量的值仅能通过PV操作来改变。

无名信号量的定义：

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);

sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。

P操作：使信号量-1

#include <semaphore.h>
int sem_wait(sem_t *sem);

sem为指向信号量结构的一个指针；

V操作：使信号量+1

#include <semaphore.h>
int sem_post(sem_t *sem);

sem为指向信号量结构的一个指针；

正常代码（可能发生死锁现象）

每一根筷子都是一个信号量，有人拿就进行P操作对拿起的筷子-1，吃完进行V操作对放下的筷子+1。
我们这里把哲学家设置都先拿左边的筷子，拿到后再拿右边的筷子，没拿到就等待别人放下筷子。
哲学家吃饭.c

/***************************************
 * 正常哲学家吃饭
 * 可能会造成死锁
 * ************************************/
#include <stdio.h> 
#include <pthread.h> 
#include <unistd.h>
#include <semaphore.h> 

sem_t sem[6];

void thread_1(void *arg)
{
    int sum = 0;
    sem_wait(&sem[1]);
    printf("111拿起1筷子\t");
    sem_wait(&sem[2]);
    printf("111拿起2筷子\t");
    printf("哲学家1吃完！\t");
    sem_post(&sem[1]);
    printf("111释放1筷子\t");
    sem_post(&sem[2]);
    printf("111释放2筷子\n");
}

void thread_2(void *arg)
{
    sem_wait(&sem[2]);
    printf("222拿起2筷子\t");
    sem_wait(&sem[3]);
    printf("222拿起3筷子\t");
    printf("哲学家2吃完!\t");
    sem_post(&sem[2]);
    printf("222释放2筷子\t");
    sem_post(&sem[3]);
    printf("222释放3筷子\n");
}

void thread_3(void *arg)
{
    sem_wait(&sem[3]);
    printf("333拿起3筷子\t");
    sem_wait(&sem[4]);
    printf("333拿起4筷子\t");
    printf("哲学家3吃完!\t");
    sem_post(&sem[3]);
    printf("333释放3筷子\t");
    sem_post(&sem[4]);
    printf("333释放4筷子\n");
}

void thread_4(void *arg)
{
    //printf("*");
    sem_wait(&sem[4]);
    printf("444拿起4筷子\t");
    //printf("A");
    sem_wait(&sem[5]);
    printf("444拿起5筷子\t");
    printf("哲学家4吃完!\t");
    sem_post(&sem[4]);
    printf("444释放4筷子\t");
    sem_post(&sem[5]);
    printf("444释放5筷子\n");
}

void thread_5(void *arg)
{
    //printf("**");
    sem_wait(&sem[5]);
    printf("555拿起5筷子\t");
    //printf("AA");
    sem_wait(&sem[1]);
    printf("555拿起1筷子\t");
    printf("哲学家5吃完!\t");
    sem_post(&sem[5]);
    printf("555释放5筷子\t");
    sem_post(&sem[1]);
    printf("555释放1筷子\n");
}

int main()
{
    pthread_t thread1;
    pthread_t thread2;
    pthread_t thread3;
    pthread_t thread4;
    pthread_t thread5;

    sem_init(&sem[1], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[2], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[3], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[4], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[5], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子

    int ret;

    //printf("%d\n%d\n%d\n%d\n%d\n",sem[1],sem[2],sem[3],sem[4],sem[5]);

    ret = pthread_create(&thread1, NULL, (void *)thread_1, NULL);
    if(ret != 0)
    {
        printf("Thread_1 wrong!\n");
    }

    ret = pthread_create(&thread2, NULL, (void *)thread_2, NULL);
    if(ret != 0)
    {
        printf("Thread_2 wrong!\n");
    }

    ret = pthread_create(&thread3, NULL, (void *)thread_3, NULL);
    if(ret != 0)
    {
        printf("Thread_3 wrong!\n");
    }

    ret = pthread_create(&thread4, NULL, (void *)thread_4, NULL);
    if(ret != 0)
    {
        printf("Thread_4 wrong!\n");
    }

    ret = pthread_create(&thread5, NULL, (void *)thread_5, NULL);
    if(ret != 0)
    {
        printf("Thread_5 wrong!\n");
    }

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);
    pthread_join(thread4, NULL);
    pthread_join(thread5, NULL);

    sem_destroy(&sem[1]);
    sem_destroy(&sem[2]);
    sem_destroy(&sem[3]);
    sem_destroy(&sem[4]);
    sem_destroy(&sem[5]);


    return 0;
}

解法1

利用信号量设置最多只能有4为哲学家同时拿左边筷子

/***************************************
 * 哲学家吃饭
 * 解法1：设置信号量限制最多只有4人同时拿起左边筷子
 * ************************************/
#include <stdio.h> 
#include <pthread.h> 
#include <unistd.h>
#include <semaphore.h> 

sem_t sem[6];

void thread_1(void *arg)
{
    int sum = 0;
    sem_wait(&sem[1]);
    printf("111拿起1筷子\n");

    sem_wait(&sem[0]);             //防止5人同时那左边筷子
    sem_wait(&sem[2]);
    printf("111拿起2筷子\n");
    printf("\n哲学家1吃完！\n");
    sem_post(&sem[1]);
    printf("111释放1筷子\n");

    sem_post(&sem[0]);
    sem_post(&sem[2]);
    printf("111释放2筷子\n");
}

void thread_2(void *arg)
{
    sem_wait(&sem[2]);
    printf("222拿起2筷子\n");

    sem_wait(&sem[0]);             //防止5人同时那左边筷子
    sem_wait(&sem[3]);
    printf("222拿起3筷子\n");
    printf("\n哲学家2吃完!\n");
    sem_post(&sem[2]);
    printf("222释放2筷子\n");

    sem_post(&sem[0]);
    sem_post(&sem[3]);
    printf("222释放3筷子\n");
}

void thread_3(void *arg)
{
    sem_wait(&sem[3]);
    printf("333拿起3筷子\n");

    sem_wait(&sem[0]);             //防止5人同时那左边筷子
    sem_wait(&sem[4]);
    printf("333拿起4筷子\n");
    printf("\n哲学家3吃完!\n");
    sem_post(&sem[3]);
    printf("333释放3筷子\n");

    sem_post(&sem[0]);
    sem_post(&sem[4]);
    printf("333释放4筷子\n");
}

void thread_4(void *arg)
{
    //printf("*");
    sem_wait(&sem[4]);
    printf("444拿起4筷子\n");

    sem_wait(&sem[0]);             //防止5人同时那左边筷子
    //printf("A");
    sem_wait(&sem[5]);
    printf("444拿起5筷子\n");
    printf("\n哲学家4吃完!\n");
    sem_post(&sem[4]);
    printf("444释放4筷子\n");

    sem_post(&sem[0]);
    sem_post(&sem[5]);
    printf("444释放5筷子\n");
}

void thread_5(void *arg)
{
    //printf("**");
    sem_wait(&sem[5]);
    printf("555拿起5筷子\n");

    sem_wait(&sem[0]);             //防止5人同时那左边筷子
    //printf("AA");
    sem_wait(&sem[1]);
    printf("555拿起1筷子\n");
    printf("\n哲学家5吃完!\n");
    sem_post(&sem[5]);
    printf("555释放5筷子\n");

    sem_post(&sem[0]);
    sem_post(&sem[1]);
    printf("555释放1筷子\n");
}

int main()
{
    pthread_t thread1;
    pthread_t thread2;
    pthread_t thread3;
    pthread_t thread4;
    pthread_t thread5;

    sem_init(&sem[0], 0, 4);              //信号量设置为4,表示只能最多4个人拿左边的筷子
    sem_init(&sem[1], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[2], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[3], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[4], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[5], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子

    int ret;

    //printf("%d\n%d\n%d\n%d\n%d\n",sem[1],sem[2],sem[3],sem[4],sem[5]);

    ret = pthread_create(&thread1, NULL, (void *)thread_1, NULL);
    if(ret != 0)
    {
        printf("Thread_1 wrong!\n");
    }

    ret = pthread_create(&thread2, NULL, (void *)thread_2, NULL);
    if(ret != 0)
    {
        printf("Thread_2 wrong!\n");
    }

    ret = pthread_create(&thread3, NULL, (void *)thread_3, NULL);
    if(ret != 0)
    {
        printf("Thread_3 wrong!\n");
    }

    ret = pthread_create(&thread4, NULL, (void *)thread_4, NULL);
    if(ret != 0)
    {
        printf("Thread_4 wrong!\n");
    }

    ret = pthread_create(&thread5, NULL, (void *)thread_5, NULL);
    if(ret != 0)
    {
        printf("Thread_5 wrong!\n");
    }

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);
    pthread_join(thread4, NULL);
    pthread_join(thread5, NULL);

    sem_destroy(&sem[0]);
    sem_destroy(&sem[1]);
    sem_destroy(&sem[2]);
    sem_destroy(&sem[3]);
    sem_destroy(&sem[4]);
    sem_destroy(&sem[5]);


    return 0;
}

解法2

对哲学家编号，奇数先拿左边偶数先那右边

/***************************************
 * 哲学家吃饭
 * 解法2：奇数先拿左边，偶数先那右边
 * ************************************/
#include <stdio.h> 
#include <pthread.h> 
#include <unistd.h>
#include <semaphore.h> 

sem_t sem[6];

void thread_1(void *arg)
{
    int sum = 0;
    sem_wait(&sem[1]);
    printf("111拿起1筷子\n");
    sem_wait(&sem[2]);
    printf("111拿起2筷子\n");
    printf("\n哲学家1吃完！\n");
    sem_post(&sem[1]);
    printf("111释放1筷子\n");
    sem_post(&sem[2]);
    printf("111释放2筷子\n");
}

void thread_2(void *arg)
{
    sem_wait(&sem[3]);
    printf("222拿起3筷子\n");
    sem_wait(&sem[2]);
    printf("222拿起2筷子\n");
    printf("\n哲学家2吃完!\n");
    sem_post(&sem[3]);
    printf("222释放3筷子\n");
    sem_post(&sem[2]);
    printf("222释放2筷子\n");
}

void thread_3(void *arg)
{
    sem_wait(&sem[3]);
    printf("333拿起3筷子\n");
    sem_wait(&sem[4]);
    printf("333拿起4筷子\n");
    printf("\n哲学家3吃完!\n");
    sem_post(&sem[3]);
    printf("333释放3筷子\n");
    sem_post(&sem[4]);
    printf("333释放4筷子\n");
}

void thread_4(void *arg)
{
    //printf("*");
    sem_wait(&sem[5]);
    printf("444拿起5筷子\n");
    sem_wait(&sem[4]);
    printf("444拿起4筷子\n");
    //printf("A");
    printf("\n哲学家4吃完!\n");
    sem_post(&sem[5]);
    printf("444释放5筷子\n");
    sem_post(&sem[4]);
    printf("444释放4筷子\n");
}

void thread_5(void *arg)
{
    //printf("**");
    sem_wait(&sem[5]);
    printf("555拿起5筷子\n");
    //printf("AA");
    sem_wait(&sem[1]);
    printf("555拿起1筷子\n");
    printf("\n哲学家5吃完!\n");
    sem_post(&sem[5]);
    printf("555释放5筷子\n");
    sem_post(&sem[1]);
    printf("555释放1筷子\n");
}

int main()
{
    pthread_t thread1;
    pthread_t thread2;
    pthread_t thread3;
    pthread_t thread4;
    pthread_t thread5;

    sem_init(&sem[1], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[2], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[3], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[4], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子
    sem_init(&sem[5], 0, 1);              //信号量设置为1,表示一次只能一个人拿该筷子

    int ret;

    //printf("%d\n%d\n%d\n%d\n%d\n",sem[1],sem[2],sem[3],sem[4],sem[5]);

    ret = pthread_create(&thread1, NULL, (void *)thread_1, NULL);
    if(ret != 0)
    {
        printf("Thread_1 wrong!\n");
    }

    ret = pthread_create(&thread2, NULL, (void *)thread_2, NULL);
    if(ret != 0)
    {
        printf("Thread_2 wrong!\n");
    }

    ret = pthread_create(&thread3, NULL, (void *)thread_3, NULL);
    if(ret != 0)
    {
        printf("Thread_3 wrong!\n");
    }

    ret = pthread_create(&thread4, NULL, (void *)thread_4, NULL);
    if(ret != 0)
    {
        printf("Thread_4 wrong!\n");
    }

    ret = pthread_create(&thread5, NULL, (void *)thread_5, NULL);
    if(ret != 0)
    {
        printf("Thread_5 wrong!\n");
    }

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);
    pthread_join(thread4, NULL);
    pthread_join(thread5, NULL);

    sem_destroy(&sem[1]);
    sem_destroy(&sem[2]);
    sem_destroy(&sem[3]);
    sem_destroy(&sem[4]);
    sem_destroy(&sem[5]);


    return 0;
}
☞ ♚ ☜
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
linux下面实现哲学家问题
11-30
在Linux操作系统下实现“哲学家问题”是一种对并发控制和多线程编程的挑战性练习。哲学家问题是由计算机科学家Edsger Dijkstra提出的，它模拟了五个坐在圆桌旁的哲学家，每人面前有一根筷子。当哲学家想要吃饭时，...
linux下gcc哲学家用餐问题
06-22
在"linux下gcc哲学家用餐问题"这个场景中，我们可以推测这是一个关于多线程或进程同步的经典问题——哲学家就餐问题（Dining Philosophers Problem）。这个问题由计算机科学家Edsger Dijkstra提出，用以阐述死锁的...
linux 多线程下互斥锁实现哲学家用餐模型
ShenHang_的博客
06-19 553
#include <stdio.h> #include <unistd.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t m[5];//定义5把锁 //哲学家i左边的筷子编号为i，右边筷子编号为i+1 void *tfn(void *arg) { int i, l, r; srand(time(NULL)); i = (int)arg; if (i == 4)//4号哲学家先拿
linux下哲学家进餐问题c代码,linux--哲学家进餐问题--代码实现-Go语言中文社区
weixin_42348880的博客
05-12 303
main.c#include "mysemop.h"#include #include #include int root_sem_id = 0;int chopsticks_sem_id[5];int main(int argc, char argv[]){pid_t pid;pid_t chldpid[5];char ch;int i = 0;int room_sem_id = CreateS...
Linux多进程4种策略实现哲学家进餐问题
BrilliantAntonio的博客
10-05 5255
1. 任务简介 一张圆桌上坐着5名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子（一根一根地拿起）。如果筷子己在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。 本实验要求利用Linux多进程实现哲学家进餐问题。 2. 思路分析 我们分析题目中的同步和互斥关系： 2.1 同步关系 本题中并不存在需要特别关注的同步关系 2.2 互
Linux下解决哲学家就餐问题
最新发布
m0_55356312的博客
03-27 512
一文解决Linux下哲学家就餐问题
Linux下实现哲学家就餐问题
热门推荐
小G的ACM之路
10-10 1万+
哲学家进餐问题是一个多线程运用的经典例子，涉及到线程同步/互斥，临界区访问问题以及一个避免死锁的解决方法。 有五个哲学家绕着圆桌坐，每个哲学家面前有一盘面，两人之间有一支筷子，这样每个哲学家左右各有一支筷子。哲学家有2个状态，思考或者拿起筷子吃饭。如果哲学家拿到一只筷子，不能吃饭，直到拿到2只才能吃饭，并且一次只能拿起身边的一支筷子。一旦拿起便不会放下筷子直到把饭吃完，此时才把这双筷子放回原处。
linux下经典同步问题,Linux经典同步问题2-哲学家就餐问题
weixin_33848693的博客
05-15 437
死锁死锁是 《操作系统原理》课程中的1个很重要的概念, 它描述的是多个进程因竞争资源而造成的1种僵局 ,若无外力作用 ,这些进程将永远不能再向前推进。产生死锁的原因主要有2点: 1是竞争资源 ; 2是进程推进顺序不当。1、哲学家就餐问题一张圆桌上坐着 5 名哲学家，桌子上每两个哲学家之间摆了一根叉子，桌子的中间是一碗米饭，如图所示，并且假如按照下面方式进行编号，那么第i为科学家，它的左手边筷子是i...
linux下哲学家就餐问题大作业
09-22
在Linux操作系统中，"哲学家就餐问题"是一个经典的多线程同步问题，它源自计算机科学家Edsger Dijkstra提出的示例，用于阐述和解决并发控制中的死锁问题。在这个大作业中，你将深入理解多线程编程以及如何在Linux...
linux C 语言模拟哲学家就餐问题
03-16
通过模拟哲学家就餐问题，我们不仅可以深入理解线程的并发行为，还能学习如何在C语言中有效地管理线程和资源，这对于理解和解决实际的多线程编程问题非常有帮助。此外，这个问题的解决方案还可以引申到其他领域的...
c语言实现哲学家就餐问题
06-27
文档为实验报告，运行环境是ubantu,文档包含哲学家就餐问题的代码，使用三种方法解决哲学家就餐问题，顺序资源法，加房间法和P_sim法，希望对大家有帮助
Linux下哲学家问题的实现
06-01
算法的思想是，每个哲学家想要进餐时，先拿左手边的筷子，如果筷子可用就拿起来，不可用就等待，再拿右手边的筷子，如果筷子可用，就拿起筷子，不可用就等待，只有当两个筷子都可用时，哲学家才能进餐。 为了实现这个算法，需要互斥锁和五个条件变量。 pthread_mutex_t mutex； pthread_cond_t chopstick[5]; 另外创建数组sticks[5]表示这五个筷子收否可用，当sticks[i]等于1时，表示筷子i可用，等于0表示这个筷子不可用。
哲学家进餐问题
12-13
【哲学家进餐问题】是计算机科学中一个经典的同步问题，最早由艾兹格·迪科斯彻提出，后来由托尼·霍尔以哲学家就餐的形象比喻来阐述。问题的核心在于模拟五个哲学家坐在一张圆桌旁，每个人面前有两根筷子。他们必须...
五个哲学家进餐问题-Linux C实现（完整代码）
m0_52857070的博客
05-27 5317
1、问题分析 五根筷子是资源，当哲学家拿到两支筷子，即左右手旁的筷子，哲学家才能吃饭。 当哲学家都拿到左手或右手的筷子后，资源都被占用，没有一个哲学家能拿到两个筷子进餐。哲学家都等待对方释放资源，这就造成了死锁。 死锁产生的条件有 （1） 互斥即资源不能共享，只能由一个进程占用 （2）占有且等待即当一个等待另外进程而阻塞时，资源不主动释放 （3）不可抢占即操作系统不能强行抢占被进程持有的资源 （3）循环等待即存在一个封闭的进程链，使得每一个进程都至少占有下个进程所需要的资源。 ...
用Linux C的互斥锁机制解决哲学家就餐问题（简单实现）
ZoMoe's eye
09-29 6410
在1971年，著名的计算机科学家艾兹格·迪科斯彻提出了一个同步问题，即假设有五台计算机都试图访问五份共享的磁带驱动器。稍后，这个问题被托尼·霍尔重新表述为哲学家就餐问题。这个问题可以用来解释死锁和资源耗尽。    「哲学家就餐说明」：有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个筷子，他们的生活方式是交替进行思考和就餐，通常，一个哲学家饥饿时就会试图去取用其左右最靠近自己的筷
哲学家进餐问题——经典进程同步问题
weixin_53236070的博客
03-21 9601
哲学家进餐问题——经典进程同步问题
哲学家就餐问题
helloworlddm的博客
06-18 903
信号量解决: 伪代码： semaphore chopstick[5] = {1,1,1,1,1}; semaphore room = 4;//房间4人 void philosophere(int i) { while (true) { think(); wait(room); wait(chopsticks[i]);//获取左手边筷子 wait(chopsticks[(i+1
linux下哲学家进餐问题
06-06
哲学家进餐问题是一个经典的并发编程问题，通常用来说明多线程同步问题。问题描述为：五个哲学家围坐在一张圆桌前，每个哲学家面前有一碗饭和一只筷子。哲学家只有在同时拿到左右两只筷子时才能进餐，进餐完毕后将...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值