这里是两种算法,公用一个chopstick类:
Chopstick类:
public class Chopstick {
/**
* 此筷子是否可以拿起
*/
private boolean enable;
/**
* 此筷子的名称
*/
public String name;
public Chopstick(boolean enable, String name) {
super();
this.enable = enable;
this.name = name;
}
public Chopstick(String name) {
this(true,name);
}
public void setEnable(boolean enbl){
this.enable = enbl;
}
public boolean getEnable(){
return this.enable;
}
/**
* 拿起筷子
*/
public synchronized void pickup(){
try{
while(this.enable == false){
wait();
}
this.enable = false;
}catch(Exception e){
}
}
/**
* 放下手中的筷子
*/
public synchronized void pickdown(){
this.enable = true;
this.notifyAll();
}
}
Philosopher类
public class Philosopher extends Thread{
private String name;
Chopstick leftChopstick;
Chopstick rightChopstick;
public Philosopher(String name, Chopstick leftChopstick,
Chopstick rightChopstick) {
super();
this.name = name;
this.leftChopstick = leftChopstick;
this.rightChopstick = rightChopstick;
}
@Override
public void run() {
super.run();
leftChopstick.pickup();
System.out.println(this.name+"拿起了左手的筷子"+leftChopstick.name);
rightChopstick.pickup();
System.out.println(this.name+"拿起了右手的筷子"+rightChopstick.name);
System.out.println(this.name+"开始吃饭了");
try {
this.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.name+"吃饱了");
rightChopstick.pickdown();
System.out.println(this.name+"放下了右手的筷子"+this.rightChopstick.name);
leftChopstick.pickdown();
System.out.println(this.name+"放下了左手的筷子"+this.leftChopstick.name);
}
}
Philosopher2
public class Philosopher2 extends Thread {
private String name;
Chopstick leftChopstick;
Chopstick rightChopstick;
public static int WITHOUTCHOPSTICK = 0;
public static int WITHONECHOPSTICK = 1;
public static int WITHTWOCHOPSTICK = 2;
public static int withChopstickStatus = 0;
public Philosopher2(String name, Chopstick leftChopstick,
Chopstick rightChopstick) {
super();
this.name = name;
this.leftChopstick = leftChopstick;
this.rightChopstick = rightChopstick;
}
@Override
public void run() {
super.run();
while (true) {
if (this.withChopstickStatus == this.WITHOUTCHOPSTICK) {
leftChopstick.pickup();
System.out.println(this.name + "拿起了左手的" + leftChopstick.name);
this.withChopstickStatus = this.WITHONECHOPSTICK;
if (this.rightChopstick.getEnable() == true) {
rightChopstick.pickup();
System.out.println(this.name + "拿起了右手的"
+ rightChopstick.name);
this.withChopstickStatus = this.WITHTWOCHOPSTICK;
System.out.println(this.name + "开始吃饭了");
try {
this.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.name + "吃饱了");
rightChopstick.pickdown();
System.out.println(this.name + "放下了右手的"
+ this.rightChopstick.name);
leftChopstick.pickdown();
System.out.println(this.name + "放下了左手的"
+ this.leftChopstick.name);
this.withChopstickStatus = this.WITHOUTCHOPSTICK;
break;
} else {
this.leftChopstick.pickdown();
System.out.println(this.name + "放下了左手的"
+ this.leftChopstick.name + ",因为右手的"
+ this.rightChopstick.name + "没法拿");
this.withChopstickStatus = this.WITHOUTCHOPSTICK;
try {
this.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
dining类
public class Dining {
/**
* @param args
*/
public static void main(String[] args) {
Chopstick chopstick1 = new Chopstick("筷子 1 ");
Chopstick chopstick2 = new Chopstick("筷子 2 ");
Chopstick chopstick3 = new Chopstick("筷子 3 ");
Chopstick chopstick4 = new Chopstick("筷子 4 ");
Chopstick chopstick5 = new Chopstick("筷子 5 ");
Philosopher philosopher1 = new Philosopher("哲学家 1 ", chopstick5,chopstick1);
Philosopher philosopher2 = new Philosopher("哲学家 2 ", chopstick1,chopstick2);
Philosopher philosopher3 = new Philosopher("哲学家 3 ", chopstick2,chopstick3);
Philosopher philosopher4 = new Philosopher("哲学家 4 ", chopstick3,chopstick4);
Philosopher philosopher5 = new Philosopher("哲学家 5 ", chopstick4,chopstick5);
long startTime = System.currentTimeMillis();
ArrayList<Thread> threads = new ArrayList<Thread>();
threads.add(philosopher1);
threads.add(philosopher2);
threads.add(philosopher3);
threads.add(philosopher4);
threads.add(philosopher5);
philosopher2.start();
philosopher4.start();
philosopher1.start();
philosopher3.start();
philosopher5.start();
for (Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(System.currentTimeMillis() - startTime);
}
}
Dining2类
public class Dining2 {
/**
* @param args
*/
public static void main(String[] args) {
Chopstick chopstick1 = new Chopstick("筷子 1 ");
Chopstick chopstick2 = new Chopstick("筷子 2 ");
Chopstick chopstick3 = new Chopstick("筷子 3 ");
Chopstick chopstick4 = new Chopstick("筷子 4 ");
Chopstick chopstick5 = new Chopstick("筷子 5 ");
Philosopher2 philosopher1 = new Philosopher2("哲学家 1 ", chopstick5,chopstick1);
Philosopher2 philosopher2 = new Philosopher2("哲学家 2 ", chopstick1,chopstick2);
Philosopher2 philosopher3 = new Philosopher2("哲学家 3 ", chopstick2,chopstick3);
Philosopher2 philosopher4 = new Philosopher2("哲学家 4 ", chopstick3,chopstick4);
Philosopher2 philosopher5 = new Philosopher2("哲学家 5 ", chopstick4,chopstick5);
long startTime = System.currentTimeMillis();
ArrayList<Thread> threads = new ArrayList<Thread>();
threads.add(philosopher1);
threads.add(philosopher2);
threads.add(philosopher3);
threads.add(philosopher4);
threads.add(philosopher5);
philosopher2.start();
philosopher4.start();
philosopher1.start();
philosopher3.start();
philosopher5.start();
for (Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(System.currentTimeMillis() - startTime);
}
}
为了防止5位哲学家同时拿筷子,同时等或是同时放下。可以让哲学家2和4先。
分享到:
相关推荐
### JAVA实现哲学家就餐问题详解 #### 背景与问题描述 哲学家就餐问题是一个经典的并发编程问题,由Edsger Dijkstra提出,用于演示死锁、饥饿、竞态条件等多线程同步问题。场景设定为五位哲学家围坐在圆桌旁,桌上...
Java是一种广泛使用的编程语言,具有丰富的类库和强大的多线程支持,非常适合用来模拟哲学家就餐问题。在Java中,我们可以使用`Thread`类来创建并运行多个线程,用`synchronized`关键字来控制对共享资源的访问,以及...
实现一个模拟哲学家进餐问题的系统,要求用户选用哪一种算法进行哲学家进餐演示。 Main 类:初始化主界面类,它结合 javaFx 提供的可图化界面设计来设计主界面 MainController 类:处理主界面鼠标选择事件的类,用来...
这个问题模拟了五个哲学家围坐在一张圆桌旁,每人面前有一根筷子。当哲学家想要吃饭时,他需要同时拿起左右两边的筷子。如果所有哲学家同时尝试拿起筷子,可能会发生一种情况,即每个人都在等待邻座的筷子,导致所有...
解决这个问题的目标是设计一种机制,使得饥饿和死锁可以避免,同时让哲学家们能尽可能多地吃饭。 在这个Java实现中,我们可能会看到以下几个关键知识点: 1. **多线程**:哲学家问题的解决方案通常涉及多线程编程...
《Java 解决哲学家就餐问题》 在计算机科学和多线程编程中,哲学家就餐问题是一个经典的示例,用于探讨线程同步、互斥以及如何避免死锁的问题。问题描述如下:五个哲学家围坐在一张圆桌旁,每个人面前有一盘面,两...
总的来说,"java模拟哲学家就餐"是一个深入理解并发编程、多线程同步和死锁问题的理想实践项目。通过这个项目,开发者可以提升自己在处理复杂并发场景下的编程能力,并学习到如何使用Java的并发工具来解决实际问题。
"模拟哲学家进餐问题"是一个经典的多线程并发控制问题,源于计算机科学与操作系统设计领域。这个问题由美国计算机科学家Edsger W. Dijkstra在20世纪60年代提出,用于探讨和解决资源竞争与死锁的问题。在这个场景中,...
Java哲学家问题是一个经典的多线程并发控制问题,源自计算机科学家Dijkstra提出的一个思想实验。在该问题中,五个哲学家围坐在一张圆桌旁,每个人面前都有一根筷子。他们交替思考(需要两根筷子才能吃饭)和吃饭。...
Java哲学家就餐问题是一个经典的多线程并发控制问题,它源于计算机科学家Edsger Dijkstra提出的一个思想实验。这个问题描述了五个哲学家围坐在一张圆桌旁,每个人面前都有一只筷子。他们交替思考和吃饭,但必须同时...
在"进程同步模拟设计--哲学家就餐问题"中,我们需要关注以下几个关键知识点: 1. **死锁**:死锁是指两个或多个并发进程各自持有对方需要的资源,导致它们都无法继续执行的状态。哲学家就餐问题就是一个典型的死锁...
哲学家就餐问题(Dining Philosophers Problem)是操作系统领域中的一个经典问题,它由计算机科学家Edsger Dijkstra在1965年提出,用于模拟并发控制中的资源竞争与死锁现象。这个问题描述了五个哲学家围坐在一张圆桌...
这个问题旨在揭示并发控制中的死锁现象,通过模拟五个哲学家(每个哲学家代表一个线程)在餐桌旁思考和吃饭的行为,来探讨如何避免资源争抢导致的死锁。在这个"philosopher_java.rar"压缩包中,包含了一个Java实现的...
4. **主程序**:创建哲学家线程并启动,模拟哲学家随机地吃饭和思考,同时保证系统不会陷入死锁。 在提供的压缩包文件"PhEat"中,很可能包含了Java代码实现的哲学家算法。代码可能展示了如何使用Java多线程来处理这...
《哲学家就餐:Java多线程实例图形版》是一个经典的多线程问题,它通过模拟哲学家们在用餐时可能出现的饥饿情况,来探讨和解决并发编程中的资源竞争问题。这个例子源自计算机科学家Edsger W. Dijkstra,他提出了这个...
在这个项目中,Java被用于编写模拟哲学家吃面问题的代码。 6. **随机数**:在模拟中,随机数生成用于决定哲学家何时从思考转为饥饿,以及选择哪个哲学家开始行动,这增加了问题的复杂性和现实感。 7. **实验报告**...
Java哲学家就餐问题是一个经典的多线程同步问题,源自计算机科学中的并发控制理论。这个问题由Edsger Dijkstra提出,旨在模拟五个哲学家在餐桌旁思考时如何避免因同时拿取左右两边的筷子而导致的饿死现象。在这个...
《编程实现哲学家就餐问题(Java)》 在多线程编程中,哲学家就餐问题是经典的一个并发控制问题,由计算机科学家Edsger Dijkstra提出。这个问题模拟了五位哲学家围坐在一张圆桌旁,每人面前有一根筷子。他们交替...