哲学家进餐问题

最新推荐文章于 2019-07-24 23:24:13 发布
最新推荐文章于 2019-07-24 23:24:13 发布
阅读量1.3k 收藏
点赞数
分类专栏： 多线程编程 文章标签： iostream 多线程 thread null c++ 测试

/********************
philosophers.cpp
哲学家进餐问题
在多线程中如何避免死锁。

问题描述：有五位哲学家围绕着餐桌坐，每一位哲学家要么思考
要么等待，要么吃饭。为了吃饭，哲学家必须拿起两双筷子（分
别放于左右两端）不幸的是，筷子的数量和哲学家相等，所以每
只筷子必须由两位哲学家共享

  下面是一种有问题的解法，因为在某个时刻，五个哲学家同时拿起五根左手边的筷子，
  则它们会在同一时候对待右手边的筷子，这样会陷入死锁，但是我测试了，这样的几
  率并不高经过几个小时，还没有出现。但是我们可以肯定，理论上是肯定会出现死锁的，
  我们不能老是靠运气办事，怎么解决这个问题呢
  留给下一步的学习吧

 


  要编译此文件请用多线程版的c++库
********************/

#include <windows.h>
#include <iostream>
#include <process.h>
#include <cstdlib>
#include <ctime>

using namespace std;
unsigned int __stdcall philosopher(void *);

void thinking(int);
void eating(int);
void wait_to_eat(int);

void outline(int ,const char *);

//全局变量
CRITICAL_SECTION crout;//这个变量用来保证输出时不会竞争

CRITICAL_SECTION fork[5];//定义五个临界变量，代表五更筷子

int main(int argc,char *argv[])
{
 void * hthread[5];
 int i;
 unsigned int threadid[5];
 int arg[5];
 int count = 5;
 unsigned long retval;

 
 InitializeCriticalSection(&crout);
 //初始化临界变量
 for(i=0;i<5;i++)
 {
  InitializeCriticalSection(fork + i);
 }
 //创建五个哲学家
 for(i = 0; i<5;i++)
 {
  arg[i] = i;
  hthread[i] = (void *)_beginthreadex(NULL,0,philosopher,(void *)(arg + i),0,threadid+i);
  if((int)hthread[i] == -1)//如果线程创建失败返回-1
  {
   cerr << "error while create thread " << i <<endl;
   cerr << "error code : "<< GetLastError() <<endl;
  }
 }
 //等待所有线程结束
 retval = WaitForMultipleObjects(5,hthread,true,INFINITE);//等待多个线程
 if(retval == WAIT_FAILED)
 {
  cerr<< "wait error,error code: "<<GetLastError()<<endl;
 }
 for(i = 0; i<5;i++)
 {
  if(CloseHandle(hthread[i]) == false)//关闭句柄
  {
   cerr << "error while close thread " <<i<<endl;
   cerr << "error code: "<<GetLastError()<<endl;
  }
 }
 return 0;
}

/*******************
哲学家的行为
吃饭，等待，思考
*******************/

unsigned int __stdcall philosopher(void *k)
{
 int n = ((int *)k)[0];
 
 outline(n," is in!");

 srand(time(NULL));
 while(true)
 {
  thinking(n);
  wait_to_eat(n);
  eating(n);
 }

 outline(n," is out!");

 return n;
}
/*************
思考
随机一段时间
*************/
void thinking(int k)
{
 outline(k," is thinking...");

 Sleep((rand()%1000) *5);
}
/*************
吃饭
随机一段时间
*************/
void eating(int k)
{
 outline(k," is eating...");
 Sleep((rand()%1000) *5);
 LeaveCriticalSection(fork + (k+1)%5);//放下右边的筷子
 //outline(k," give left");
 LeaveCriticalSection(fork + k);//放下左边的筷子
 //outline(k," give right");
}
/***************
等待吃饭
需要同时获得他两边的筷子
***************/
void wait_to_eat(int k)
{
 outline(k," is waiting...");
 EnterCriticalSection(fork + k);//获得左边的筷子
 //outline(k," take left");
 EnterCriticalSection(fork + (k + 1)%5);//获得右边的筷子
 //outline(k," take right");
}
/********************
//没有竞争条件的输出函数
********************/
void outline(int who,const char *str)
{
 EnterCriticalSection(&crout);
 cout<<"process "<<who<<str<<endl;
 LeaveCriticalSection(&crout);
}

 

/********************
philosophers.cpp
哲学家进餐问题
在多线程中如何避免死锁。

问题描述：有五位哲学家围绕着餐桌坐，每一位哲学家要么思考
要么等待，要么吃饭。为了吃饭，哲学家必须拿起两双筷子（分
别放于左右两端）不幸的是，筷子的数量和哲学家相等，所以每
只筷子必须由两位哲学家共享

  下面是一种有问题的解法，因为在某个时刻，五个哲学家同时拿起五根左手边的筷子，
  则它们会在同一时候对待右手边的筷子，这样会陷入死锁，但是我测试了，这样的几
  率并不高经过几个小时，还没有出现。但是我们可以肯定，理论上是肯定会出现死锁的，
  我们不能老是靠运气办事，怎么解决这个问题呢
  留给下一步的学习吧
  要编译此文件请用多线程版的c++库

  WWW.54SH.COM
  MADE BY EFISH

  下面经过了一些修改，把哲学家的个数作为一个宏定义，并减少哲学家的个数为2，

    死锁现象马上出现了，真不走运!
********************/

#include <windows.h>
#include <iostream>
#include <process.h>
#include <cstdlib>
#include <ctime>

#define NUM_OF_PH 2 //哲学家的个数

using namespace std;
unsigned int __stdcall philosopher(void *);

void thinking(int);
void eating(int);
void wait_to_eat(int);

void outline(int ,const char *);

//全局变量
CRITICAL_SECTION crout;//这个变量用来保证输出时不会竞争

CRITICAL_SECTION fork[NUM_OF_PH];//定义五个临界变量，代表五更筷子

int main(int argc,char *argv[])
{
 void * hthread[NUM_OF_PH];
 int i;
 unsigned int threadid[NUM_OF_PH];
 int arg[NUM_OF_PH];
 int count = NUM_OF_PH;
 unsigned long retval;

 
 InitializeCriticalSection(&crout);
 //初始化临界变量
 for(i=0;i<NUM_OF_PH;i++)
 {
  InitializeCriticalSection(fork + i);
 }
 //创建五个哲学家
 for(i = 0; i<NUM_OF_PH;i++)
 {
  arg[i] = i;
  hthread[i] = (void *)_beginthreadex(NULL,0,philosopher,(void *)(arg + i),0,threadid+i);
  if((int)hthread[i] == -1)//如果线程创建失败返回-1
  {
   cerr << "error while create thread " << i <<endl;
   cerr << "error code : "<< GetLastError() <<endl;
  }
 }
 //等待所有线程结束
 retval = WaitForMultipleObjects(NUM_OF_PH,hthread,true,INFINITE);//等待多个线程
 if(retval == WAIT_FAILED)
 {
  cerr<< "wait error,error code: "<<GetLastError()<<endl;
 }
 for(i = 0; i<NUM_OF_PH;i++)
 {
  if(CloseHandle(hthread[i]) == false)//关闭句柄
  {
   cerr << "error while close thread " <<i<<endl;
   cerr << "error code: "<<GetLastError()<<endl;
  }
 }
 return 0;
}

/*******************
哲学家的行为
吃饭，等待，思考
*******************/

unsigned int __stdcall philosopher(void *k)
{
 int n = ((int *)k)[0];
 
 outline(n," is in!");

 srand(time(NULL));
 while(true)
 {
  thinking(n);
  wait_to_eat(n);
  eating(n);
 }

 outline(n," is out!");

 return n;
}
/*************
思考
随机一段时间
*************/
void thinking(int k)
{
 outline(k," is thinking...");

 Sleep((rand()%1000) *NUM_OF_PH);
}
/*************
吃饭
随机一段时间
*************/
void eating(int k)
{
 outline(k," is eating...");
 Sleep((rand()%1000) *NUM_OF_PH);
 LeaveCriticalSection(fork + (k+1)%NUM_OF_PH);//放下右边的筷子
 outline(k," give left");
 LeaveCriticalSection(fork + k);//放下左边的筷子
 outline(k," give right");
}
/***************
等待吃饭
需要同时获得他两边的筷子
***************/
void wait_to_eat(int k)
{
 outline(k," is waiting...");
 EnterCriticalSection(fork + k);//获得左边的筷子
 outline(k," take left");
 EnterCriticalSection(fork + (k + 1)%NUM_OF_PH);//获得右边的筷子
 outline(k," take right");
}
/********************
//没有竞争条件的输出函数
********************/
void outline(int who,const char *str)
{
 EnterCriticalSection(&crout);
 cout<<"process "<<who<<str<<endl;
 LeaveCriticalSection(&crout);
}

 

/********************
philosophers.cpp
哲学家进餐问题
在多线程中如何避免死锁。

问题描述：有五位哲学家围绕着餐桌坐，每一位哲学家要么思考
要么等待，要么吃饭。为了吃饭，哲学家必须拿起两双筷子（分
别放于左右两端）不幸的是，筷子的数量和哲学家相等，所以每
只筷子必须由两位哲学家共享

  下面是一种有问题的解法，因为在某个时刻，五个哲学家同时拿起五根左手边的筷子，
  则它们会在同一时候对待右手边的筷子，这样会陷入死锁，但是我测试了，这样的几
  率并不高经过几个小时，还没有出现。但是我们可以肯定，理论上是肯定会出现死锁的，
  我们不能老是靠运气办事，怎么解决这个问题呢
  留给下一步的学习吧
  要编译此文件请用多线程版的c++库

  WWW.54SH.COM
  MADE BY EFISH

  下面经过了一些修改，把哲学家的个数作为一个宏定义，并减少哲学家的个数为2
  死锁现象马上出现了，真不走运!

  进行了一些改变，把临界变量变成了互斥变量，让每一个哲学家同时等待每一个
  两更筷子
********************/

#include <windows.h>
#include <iostream>
#include <process.h>
#include <cstdlib>
#include <ctime>

#define NUM_OF_PH 3 //哲学家的个数

using namespace std;
unsigned int __stdcall philosopher(LPVOID);

void thinking(int);
void eating(int);
void wait_to_eat(int);

inline void outline(int ,const char *);

//全局变量
CRITICAL_SECTION crout;//这个变量用来保证输出时不会竞争

//CRITICAL_SECTION fork[NUM_OF_PH];//定义五个临界变量，代表五更筷子
//修改之后，用了互斥变量两
void *mutex[NUM_OF_PH + 1];

int main(int argc,char *argv[])
{
 void * hthread[NUM_OF_PH];
 int i;
 unsigned int threadid[NUM_OF_PH];
 int arg[NUM_OF_PH];
 int count = NUM_OF_PH;
 unsigned long retval;

 
// InitializeCriticalSection(&crout);
 //初始化临界变量
 for(i=0;i<NUM_OF_PH;i++)
 {
//  InitializeCriticalSection(fork + i);
  mutex[i] = CreateMutex(NULL,false,NULL);
 }
// mutex[NUM_OF_PH] = mutex[NUM_OF_PH -1];
 //创建五个哲学家
 for(i = 0; i<NUM_OF_PH;i++)
 {
  arg[i] = i;
  hthread[i] = (void *)_beginthreadex(NULL,0,philosopher,(LPVOID)(arg + i),0,threadid+i);
  if((int)hthread[i] == -1)//如果线程创建失败返回-1
  {
   cerr << "error while create thread " << i <<endl;
   cerr << "error code : "<< GetLastError() <<endl;
  }
 }
 //等待所有线程结束
 retval = WaitForMultipleObjects(NUM_OF_PH,hthread,true,INFINITE);//等待多个线程
 if(retval == WAIT_FAILED)
 {
  cerr<< "wait error,error code: "<<GetLastError()<<endl;
 }
 for(i = 0; i<NUM_OF_PH;i++)
 {
  if(CloseHandle(hthread[i]) == false)//关闭句柄
  {
   cerr << "error while close thread " <<i<<endl;
   cerr << "error code: "<<GetLastError()<<endl;
  }
 }
 return 0;
}

/*******************
哲学家的行为
吃饭，等待，思考
*******************/

unsigned int __stdcall philosopher(LPVOID k)
{
 int n = *(int *) k;
 outline(n," is in!");

 srand(time(NULL));
 while(true)
 {
  thinking(n);
  wait_to_eat(n);
  eating(n);
 }

 outline(n," is out!");

 return n;
}
/*************
思考
随机一段时间
*************/
void thinking(int k)
{
 outline(k," is thinking...");

 Sleep((rand()%1000) *NUM_OF_PH);
}
/*************
吃饭
随机一段时间
*************/
void eating(int k)
{
 outline(k," is eating...");
 Sleep((rand()%1000) *NUM_OF_PH);
 /*
 LeaveCriticalSection(fork + (k+1)%NUM_OF_PH);//放下右边的筷子
 outline(k," give left");
 LeaveCriticalSection(fork + k);//放下左边的筷子
 outline(k," give right");
 */
 ReleaseMutex(mutex[k]);
 outline(k," give left");
 ReleaseMutex(mutex[k+1]);
 outline(k," give right");
}
/***************
等待吃饭
需要同时获得他两边的筷子
***************/
void wait_to_eat(int k)
{
 outline(k," is waiting...");
 /*
 EnterCriticalSection(fork + k);//获得左边的筷子
 outline(k," take left");
 EnterCriticalSection(fork + (k + 1)%NUM_OF_PH);//获得右边的筷子
 outline(k," take right");
 */
 //同时等待两根筷子
 WaitForMultipleObjects(2,mutex + k,true,INFINITE);
 outline(k," get two");
}
/********************
//没有竞争条件的输出函数
********************/
void outline(int who,const char *str)
{
 EnterCriticalSection(&crout);
 cout<<"process "<<who<<str<<endl;
 LeaveCriticalSection(&crout);
}

 
maliang1225
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
5位哲学家吃饭问题（算法描述）
唯一谣|Airs|走尽天涯路|极地阳光
09-18 2948
/*设有5个哲学家，共享一张放有5把椅子的桌子，每人分得一把椅子，但是，桌子上共有5只筷子，在每人两边各放一只，哲学家们在肚子饥饿时才试图分两次从两边拿起筷子就餐。条件：1）拿到两只筷子时哲学家才开始吃饭。2）如果筷子已在他人手上，则该哲学家必须等他人吃完之后才能拿到筷子。3）任一哲学家在自己未拿到两只筷子前却不放下自己手中的筷子。试：1）描述一 个保证不会出现两个邻座同时
模拟5位哲学家进餐的问题
06-29
每个事件发生就打印一行。并用gettimeofday()显示毫秒 。 A. 用'X' 表示哲学家在进餐 B. 用'O' 表示哲学家在思考 C. 用'!' 表示哲学家饿了 例子： 1 2 3 4 5 0 ms: O O O O O 95 ms: ! O O O O 95 ms: X O O O O 214 ms: X O O O ! 327 ms: X O O ! ! 328 ms: X O O X ! 444 ms: O ! O O ! 444 ms: O X O O X
哲学家就餐问题 C语言实现
weixin_30615767的博客
06-06 980
场景： 原版的故事里有五个哲学家(不过我们写的程序可以有N个哲学家)，这些哲学家们只做两件事－－思考和吃饭，他们思考的时候不需要任何共享资源，但是吃饭的时候就必须使用餐具，而餐桌上的餐具是有限的，原版的故事里，餐具是叉子，吃饭的时候要用两把叉子把面条从碗里捞出来。很显然把叉子换成筷子会更合理，所以：一个哲学家需要两根筷子才能吃饭。 现在引入问题的关键：这些哲学家很穷，只买得起五根筷子。他...
哲学家进餐问题的代码
05-05
有三个.cpp文件，代码是我亲手写的，都可以运行，这个代码包含有3种方式避免死锁的方法，一个是允许四个哲学家同时进餐，第二个是一下子就拿两根筷子，否则不拿，第三个就是奇数哲学家先拿左边的筷子，偶数哲学家拿...
java实现哲学家进餐问题
05-21
有五个哲学家，他们的生活方式是交替地进行思考和进餐。他们共用一张圆桌，分别坐在五张椅子上。 在圆桌上有五个碗和五把叉子，平时...哲学家进餐问题可看作是并发进程并发执行时处理共享资源的一个有代表性的问题。
操作系统：哲学家进餐问题（p,v操作实现互斥与同步）
03-27
分析哲学家进餐问题，p,v操作实现互斥与同步，分析记录性信号量的不足，并指出给改进方法 方法一：最多允许4人同时进餐； 方法二：分奇偶数进餐，以及AND型信号量解决该问题。 （免费下载，无需积分）
哲学家进餐问题.zip
07-29
在这个"哲学家进餐问题.zip"压缩包中，包含了三个关键文件：一个C++源代码文件（哲学家进餐问题.cpp）、一个详细实现文档（哲学家进餐问题.doc）和一个可执行文件（哲学家进餐问题.exe）。.vscode文件夹可能是开发...
并发编程 - 哲学家就餐问题
john dong
07-24 587
题目 哲学家就餐问题是由并发处理的先驱E.W.Dijkstra所提出，主要用于阐述死锁和无饥饿概念。假设五个哲学家一生只在思考和就餐。他们围坐在一个大圆桌旁，桌上有一大盘米饭。然而只有五根可用的筷子。所有的哲学家都在思考。若某个哲学家饿了，则拿起身边的两根筷子。如果他能够拿到这两根筷子，则可以就餐。当这个哲学家吃完后，又放下自己生变的两根筷子。如果他能够拿到这两根筷子，则可以就餐。当这个哲学家吃完...
C-多线程-哲学家进餐问题
非程序员专栏
09-17 642
网易公开课，哲学家进餐问题，VC2010控制台程序 // testVC.cpp : 哲学家进餐问题。 // #include "stdafx.h" HANDLE hSemaphoreForks[5]; //5个叉子使用状态 HANDLE hSemaphoreNumEat; //可以同时进餐的哲学家数量 DWORD _stdcall PhilosopherProc(LPVOID lp
哲学家就餐问题
iteye_9759的博客
04-02 198
哲学家就餐问题是经典的进程同步问题，而以下解决思路也堪称经典。    n  哲学家进餐问题 n  解决思路1：只允许4位哲学家同时拿筷子。此时必然有一个哲学家能拿到2根筷子。 n  如何保证只有4位哲学家同时拿筷子？ n  可以设置一个初值为4的资源信号量。比如，4张椅子，哲学家进餐之前必须先拿到椅子才能做到桌前拿筷子。进餐完毕后，不但要释放筷子，还要释放椅子。 n  哲学家进餐问...
死锁之五个哲学家就餐问题 C语言实现
qq_40394168的博客
05-25 7177
#include&lt;stdio.h&gt;#include&lt;process.h&gt;#include&lt;windows.h&gt;#include&lt;stdlib.h&gt;#include&lt;math.h&gt;HANDLE Mutext[5];int chopstick = 0;int *Physical;unsigned int _stdcall ThreadFun(...
哲学家就餐问题的C#实现
06-30 3318
撰文：周翔 这是我在上操作系统课的那个学期写的一段程序，并组织成了一篇文章。当初被我的挚友曾毅发表在CSTC的论坛上：http://cstc.net.cn/bbs/viewtopic.php?t=457，在此，我把它贴在这儿，希望对大家有所裨益。   学操作系统的进程同步都要涉及到三个经典问题：生产者-消费者问题、读者-写者问题和哲学家就餐问题。下面来介绍一下哲学家就餐问题： 哲学家就餐问题中，一
操作系统专业课程设计-哲学家进餐问题样本.doc
最新发布
12-19
在本操作系统专业课程设计中，主题是"哲学家进餐问题"，这是一个经典的问题，通常用于教授并发控制和死锁概念。学生们被要求为N个哲学家设计一个解决方案，其中每个哲学家需要两只餐叉来进餐，而餐桌上的餐叉数量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值