精华内容
下载资源
问答
  • 哲学家进餐

    2011-12-26 21:42:14
    经典的哲学家进餐问题的windows代码实现
  • 哲学家进餐问题代码

    2016-05-27 18:25:15
    哲学家进餐问题代码
  • 有五个哲学家,他们的生活方式是交替地进行思考和进餐。他们共用一张圆桌,分别坐在五张椅子上。 在圆桌上有五个碗和五把叉子,平时...哲学家进餐问题可看作是并发进程并发执行时处理共享资源的一个有代表性的问题。
  • 哲学家进餐问题

    2011-11-08 13:09:44
    哲学家进餐问题
  • 哲学家进餐例子

    2012-08-18 19:52:35
    哲学家进餐的一个小程序,5个哲学家围坐在一张圆桌周围,每个哲学家面前有一碟通心面,要使用筷子才能进餐。相邻两个碟子之间有一根筷子。哲学家包含三种状态:吃饭、思考和挨饿。当一个哲学家觉得饿时,他才试图分两...
  • 哲学家进餐问题ppt

    2018-06-09 13:36:26
    哲学家进餐问题的解决方案图示 。
  • 哲学家进餐问题源码.zip
  • C#哲学家进餐算法

    2014-05-30 15:01:45
    .NET哲学家进餐算法,vs2010可打开,面向对象设计
  • 哲学家进餐问题(The Dinning Philosophers Problem)是由荷兰学者Dijkstra提出的经典的同步问题之一。 问题:有五个哲学家,他们的生活方式是交替地进行思考和进餐,哲学家们共用一张圆桌,分别坐在周围的五张椅子...

    哲学家进餐问题(The Dinning Philosophers Problem)是由荷兰学者Dijkstra提出的经典的同步问题之一。

    问题:有五个哲学家,他们的生活方式是交替地进行思考和进餐,哲学家们共用一张圆桌,分别坐在周围的五张椅子上,在圆桌上有五个碗和五支筷子,平时哲学家进行思考,饥饿时便试图取其左、右最靠近他的筷子,只有在他拿到两支筷子时才能进餐,该哲学家进餐完毕后,放下左右两只筷子又继续思考。

    对于哲学家进餐问题可能造成的死锁问题,可采取以下几种解决方法:

    1. 至多只允许有四位哲学家同时去拿左边的筷子,最终能保证至少有一位哲学家能够进餐,并在用毕时能释放出他用过的两只筷子,从而使更多的哲学家能够进餐。
    2. 仅当哲学家的左、右两只筷子均可用时,才允许他拿起筷子进餐。
    3. 规定奇数号哲学家先拿他左边的筷子,然后再去拿右边的筷子;而偶数号哲学家则相反。按此规定,将是1、2号哲学家竞争1号筷子;3、4号哲学家竞争3号筷子。即五位哲学家都先争奇数号筷子,获得后,再去竞争偶数号筷子,最后总有一位哲学家能获得两只筷子而进餐。

    参考文章:https://baike.baidu.com/item/哲学家进餐问题/274185?fr=aladdin

    展开全文
  • 哲学家进餐实验报告

    2018-11-18 14:42:42
    哲学家进餐问题,非线程完成,c++核心代码,武汉理工大学实验报告
  • 模拟哲学家进餐问题.rar
  • 哲学家进餐问题.rar

    2011-11-22 22:20:44
    多线程机制解决哲学家进餐问题的解决策略.pdf 计算机操作系统中哲学家进餐问题探究.pdf 浅析Linux中的共享内存机制.pdf 用附加规则解决哲学家进餐问题.pdf 哲学家进餐问题的一种解决方案.pdf
  • PV操作经典例题——哲学家进餐问题

    万次阅读 多人点赞 2019-04-10 11:31:14
    哲学家进餐问题: 五个哲学家共用一张圆桌,分别坐在周围的五张椅子上,在桌子上有五只碗和五只筷子,他们的生活方式是交替地进行思考和进餐。平时,一个哲学家进行思考,饥饿时便试图取用其左右最靠近他的筷子,...

    哲学家进餐问题:
    五个哲学家共用一张圆桌,分别坐在周围的五张椅子上,在桌子上有五只碗和五只筷子,他们的生活方式是交替地进行思考和进餐。平时,一个哲学家进行思考,饥饿时便试图取用其左右最靠近他的筷子,只有在他拿到两只筷子时才能进餐。进餐毕,放下筷子继续思考。
    在这里插入图片描述
    分析:放在桌子上的筷子是临界资源,在一段时间内只允许一位哲学家使用,为了实现对筷子的互斥访问,可以用一个信号量表示筷子,由这五个信号量构成信号量数组。

    semaphore chopstick[5] = {1,1,1,1,1};
    while(true)
    {
    	/*当哲学家饥饿时,总是先拿左边的筷子,再拿右边的筷子*/
    	wait(chopstick[i]);
    	wait(chopstick[(i+1)%5]);
    
    	// 吃饭
     
    	/*当哲学家进餐完成后,总是先放下左边的筷子,再放下右边的筷子*/
    	signal(chopstick[i]);
    	signal(chopstick[(i+1)%5]);
    }
    
    • 上述的代码可以保证不会有两个相邻的哲学家同时进餐,但却可能引起死锁的情况。假如五位哲学家同时饥饿而都拿起的左边的筷子,就会使五个信号量chopstick都为0,当他们试图去拿右手边的筷子时,都将无筷子而陷入无限期的等待。

    为避免死锁,可以使用以下三种策略

    策略一:至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释放出他所使用过的两支筷子,从而可使更多的哲学家进餐。定义信号量count,只允许4个哲学家同时进餐,这样就能保证至少有一个哲学家可以就餐。

    semaphore chopstick[5]={1,1,1,1,1};
    semaphore count=4; // 设置一个count,最多有四个哲学家可以进来
    void philosopher(int i)
    {
    	while(true)
    	{
    		think();
    		wait(count); //请求进入房间进餐 当count为0时 不能允许哲学家再进来了
    		wait(chopstick[i]); //请求左手边的筷子
    		wait(chopstick[(i+1)%5]); //请求右手边的筷子
    		eat();
    		signal(chopstick[i]); //释放左手边的筷子
    		signal(chopstick[(i+1)%5]); //释放右手边的筷子
    		signal(count); //离开饭桌释放信号量
    	}
    }
    

    策略二:仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐。可以利用AND 型信号量机制实现,也可以利用信号量的保护机制实现。利用信号量的保护机制实现的思想是通过记录型信号量mutex对取左侧和右侧筷子的操作进行保护,使之成为一个原子操作,这样可以防止死锁的出现。描述如下:

    1. 用记录型信号量实现:
    semaphore mutex = 1; // 这个过程需要判断两根筷子是否可用,并保护起来
    semaphore chopstick[5]={1,1,1,1,1};
    void philosopher(int i)
    {
    	while(true)
    	{
    		/* 这个过程中可能只能由一个人在吃饭,效率低下,有五只筷子,其实是可以达到两个人同时吃饭 */
    		think();
    		wait(mutex); // 保护信号量
    		wait(chopstick[(i+1)%5]); // 请求右手边的筷子
    		wait(chopstick[i]); // 请求左手边的筷子
    		signal(mutex); // 释放保护信号量
    		eat();
    		signal(chopstick[(i+1)%5]); // 释放右手边的筷子
    		signal(chopstick[i]); // 释放左手边的筷子
    	}
    }
    
    1. 用AND型信号量实现:
    semaphore chopstick[5]={1,1,1,1,1};
    do{
    	//think()
    	Swait(chopstick[(i+1)%5],chopstick[i]);
    	//eat()
    	Ssignal(chopstick[(i+1)%5],chopstick[i]);
    }while(true)
    

    策略三:规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子;而偶数号的哲学家则先拿起他右边的筷子,然后再去拿他左边的筷子。按此规定,将是1、2号哲学家竞争1号筷子,3、4号哲学家竞争3号筷子。即五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获得两支筷子而进餐。

    semaphore chopstick[5]={1,1,1,1,1};
    void philosopher(int i)
    {
    	while(true)
    	{
    		think();
    		if(i%2 == 0) //偶数哲学家,先右后左。
    		{
    			wait (chopstick[(i + 1)%5]) ;
    			wait (chopstick[i]) ;
    			eat();
    			signal (chopstick[(i + 1)%5]) ;
    			signal (chopstick[i]) ;
    		}
    		else //奇数哲学家,先左后右。
    		{
    			wait (chopstick[i]) ;
    			wait (chopstick[(i + 1)%5]) ;
    			eat();
    			signal (chopstick[i]) ;
    			signal (chopstick[(i + 1)%5]) ;
    		}
    	}
    }
    
    展开全文
  • 主要介绍了Java模拟死锁发生之演绎哲学家进餐问题,结合具体演绎哲学家进餐问题的案例形式详细分析了死锁机制与原理,需要的朋友可以参考下
  • 【操作系统】“哲学家进餐”问题

    万次阅读 多人点赞 2016-12-09 14:15:21
    哲学家进餐”问题有五个哲学家,他们的生活方式是交替地进行思考和进餐。他们共用一张圆桌,分别坐在五张椅子上。在圆桌上有五个碗和五支筷子,平时一个哲学家进行思考,饥饿时便试图取用其左、右最靠近他的筷子,...

    “哲学家进餐”问题

    有五个哲学家,他们的生活方式是交替地进行思考和进餐。他们共用一张圆桌,分别坐在五张椅子上。

    在圆桌上有五个碗和五支筷子,平时一个哲学家进行思考,饥饿时便试图取用其左、右最靠近他的筷子,只有在他拿到两支筷子时才能进餐。进餐完毕,放下筷子又继续思考。

    图示

    哲学家进餐问题可看作是并发进程并发执行时处理共享资源的一个有代表性的问题。

    图示

    此算法可以保证不会有相邻的两位哲学家同时进餐。

    若五位哲学家同时饥饿而各自拿起了左边的筷子,这使五个信号量 chopstick 均为 0,当他们试图去拿起右边的筷子时,都将因无筷子而无限期地等待下去,即可能会引起死锁。

    哲学家进餐问题的改进解法

    • 方法一:至多只允许四位哲学家同时去拿左筷子,最终能保证至少有一位哲学家能进餐,并在用完后释放两只筷子供他人使用。
    • 方法二:仅当哲学家的左右手筷子都拿起时才允许进餐。
    • 方法三:规定奇数号哲学家先拿左筷子再拿右筷子,而偶数号哲学家相反。

    方法一

    至多只允许四位哲学家同时去拿左筷子,最终能保证至少有一位哲学家能进餐,并在用完后释放两只筷子供他人使用。

    设置一个初值为 4 的信号量 r,只允许 4 个哲学家同时去拿左筷子,这样就能保证至少有一个哲学家可以就餐,不会出现饿死和死锁的现象。

    原理:至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释放出他所使用过的两支筷子,从而可使更多的哲学家进餐。

    图示

    方法二

    仅当哲学家的左右手筷子都拿起时才允许进餐。

    解法 1:利用 AND 型信号量机制实现。

    原理:多个临界资源,要么全部分配,要么一个都不分配,因此不会出现死锁的情形。

    图示

    解法 2:利用信号量的保护机制实现。

    原理:通过互斥信号量 mutex 对 eat() 之前取左侧和右侧筷子的操作进行保护,可以防止死锁的出现。

    图示

    方法三

    规定奇数号哲学家先拿左筷子再拿右筷子,而偶数号哲学家相反。

    原理:按照下图,将是 2,3 号哲学家竞争 3 号筷子,4,5 号哲学家竞争 5 号筷子。1 号哲学家不需要竞争。最后总会有一个哲学家能获得两支筷子而进餐。

    图示

    图示

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,755
精华内容 1,502
关键字:

哲学家进餐