package tianya.cn.philopherfood;
public class Chopstick {
private static int count = 0;
private int number = count++;
public String toString(){
return "Chopstick" + number;
}
}
===========================================
package tianya.cn.philopherfood;
import java.util.Random;
public class Philosopher extends Thread {
private static Random random = new Random();
private static int count = 0;
private int number = count++;
private Chopstick leftChopstick;
private Chopstick rightChopstick;
public static int ponder = 0;//package access,time of philosopher thinking
public Philosopher(Chopstick left, Chopstick right){
leftChopstick = left;
rightChopstick = right;
start();
}
public void thinking(){
System.out.println();
if(ponder > 0){
try {
sleep(random.nextInt(ponder));
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void eat(){
synchronized (leftChopstick) {
System.out.println(this + " has " + this.leftChopstick + " waitting for " + this.rightChopstick);
}
synchronized (rightChopstick) {
System.out.println(this + "eating");
}
}
public String toString(){
return "Philospher" + number;
}
public void run(){
while(true){
thinking();
eat();
}
}
}
==========================================================
package tianya.cn.main;
import java.util.Timer;
import java.util.TimerTask;
import tianya.cn.philopherfood.Chopstick;
import tianya.cn.philopherfood.Philosopher;
public class DiningPhilosophers {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
if( args.length < 3){
System.err.println("输入参数错误!。。。。。。。");
System.exit(0);
}
Philosopher[] philosopher = new Philosopher[ Integer.parseInt(args[0]) ];
Philosopher.ponder = Integer.parseInt( args[1] );
Chopstick
left = new Chopstick(),
right = new Chopstick(),
first = left;
int i = 0;
if(i < philosopher.length - 1){
philosopher[i++] = new Philosopher(left, right);
left = right;
right = new Chopstick();
}
if(args[2].equals("deadlock")){
philosopher[i] = new Philosopher(left, first);
}else{
//swaping values prevents deadblock
philosopher[i] = new Philosopher(first, left);
}
//
if(args.length > 3){
int delay = Integer.parseInt( args[3] );
new Timer().schedule(new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("OVER!!!");
System.exit(0);
}
}, delay);
}
}
}
相关推荐
`Main.java`文件是程序的入口,它会创建哲学家和筷子对象,并启动哲学家线程。 ```java public class Main { public static void main(String[] args) { Fork[] forks = new Fork[5]; for (int i = 0; i ; i++) {...
// 创建哲学家线程 std::thread philosophers[5]; for (int i = 0; i ; ++i) { philosophers[i] = std::thread(philosopher, i); } // 等待所有哲学家完成 for (auto& philosopher : philosophers) { ...
《哲学家进餐问题与C/C++多线程同步实践》 在计算机科学领域,多线程编程是一项关键技能,特别是在解决并发问题时。这里我们关注的是一个经典的并发问题——哲学家进餐问题(Dining Philosophers Problem)。该问题...
《哲学家就餐:Java多线程实例图形版》是一个经典的多线程问题,它通过模拟哲学家们在用餐时可能出现的饥饿情况,来探讨和解决并发编程中的资源竞争问题。这个例子源自计算机科学家Edsger W. Dijkstra,他提出了这个...
哲学家就餐问题是多线程编程中经典的一个死锁问题,它展示了并发操作中可能出现的资源竞争与死锁现象。在这个问题中,我们有6位哲学家围坐在一张圆桌旁,每位哲学家需要两支筷子才能吃饭。筷子在哲学家之间交替放置...
在这个类中,我们可以创建哲学家线程并启动他们,让他们按照预定的策略进行操作。使用Java的`Thread.join()`方法,可以确保哲学家在吃完饭后才继续执行下一轮。 在实现过程中,还可以添加图形用户界面(GUI),让...
哲学家吃饭问题是一个经典的多线程同步问题,源自计算机科学先驱Dijkstra提出的并发控制问题。在这个问题中,五个哲学家围坐在一张圆桌旁,每个人面前都有一根筷子。当一个哲学家想要吃饭时,他需要拿起左右两边的两...
总结来说,"Linux下进程的哲学家进餐"是一个通过System V信号量解决经典并发问题的例子,它展示了如何在多进程环境中有效地管理资源,防止死锁的发生。通过对这个问题的研究,我们可以深入理解Linux进程通信机制,...
总的来说,哲学家就餐问题是一个生动的并发控制和死锁问题的例子,它在计算机科学教育和研究中具有重要地位。通过理解和解决这个问题,我们可以更好地设计并发程序,避免实际系统中可能出现的类似问题。文件"jiucan....
为了吃饭,哲学家需要同时拿到左右两边的筷子。问题在于如何设计一个机制,使得哲学家们既能交替用餐,又不会导致死锁或饥饿情况。 死锁是指多个进程互相等待对方释放资源,导致所有进程都无法继续进行的状态。在...
哲学家就餐问题就是一个典型的资源竞争例子,每个哲学家代表一个线程,筷子是共享资源。 2. **死锁**:当两个或更多线程互相等待对方释放资源而无法继续执行时,就发生了死锁。在哲学家就餐问题中,若所有哲学家...
其中,"哲学家就餐问题"是一个经典的多线程同步问题,它在UCOS-II上的实现具有重要的学习和研究价值。 哲学家就餐问题由计算机科学家Edsger W. Dijkstra提出,用以模拟并发控制中的资源争抢现象。问题描述如下:五...
如果哲学家们同时拿起相邻的两根筷子,就可能导致所有人都无法吃饭,即出现死锁状态。 在这个Java实现的版本中,我们将深入探讨如何避免这种情况。首先,我们需要理解死锁的概念。在计算机系统中,死锁是指两个或多...
目标是避免所有哲学家同时思考而无法吃饭(死锁状态)。在Java中,我们可以通过使用锁来解决这个问题,而不是传统的PV操作(信号量)。 首先,我们需要理解Java中的锁机制。Java提供了多种锁,包括`synchronized`...
// 创建N个哲学家线程 int temp[N]; for (int i = 0; i ; ++i) { temp[i] = i; hThreads[i] = CreateThread(NULL, 0, Philosopher, &temp[i], 0, &PhilosopherID[i]); // 各个参数分别为: // 指向SECURITY_...
操作系统课程设计中的“哲学家算法”是一个经典的多线程同步问题,源于计算机科学家 Edsger Dijkstra 提出的示例。这个例子描述了五个哲学家围坐在一张圆桌旁,每人一边有一根筷子。他们思考时需要两根筷子来吃饭。...
2. **死锁**:死锁是操作系统中的重要概念,哲学家就餐问题就是死锁的一个经典例子。当哲学家们各自持有一根筷子并等待其他筷子时,就可能出现无法继续进行的情况。理解并避免死锁是解决这个问题的关键。 3. **资源...
哲学家就餐问题是多线程同步的另一个著名例子,由Dijkstra提出。假设五个哲学家围坐在一张圆桌旁,每人都有一根筷子,相邻的哲学家之间共享一双筷子。当一个哲学家想吃饭时,他需要拿起左右两边的筷子。如果所有哲学...
哲学家进餐问题是计算机科学中一个经典的并发控制问题,用于展示在多线程或多进程环境中资源竞争与死锁的问题。该问题设定如下:有五个哲学家围坐在一张圆桌旁,每个哲学家面前有一盘食物(假设为面条),而每两个...