哲学家就餐问题

循环：
思考问题；
尝试拿左边叉子；
尝试拿右边叉子；
吃面；
放下左边叉子；
放下右边的叉子；

循环：
思考问题；
申请权利；
吃面；
放弃权利；
通知；

import java.io.File;
import java.io.FileWriter;

public class Philosopher  extends Thread {
private int state; //表示哲学家的状态，0思考、1表示饥饿和2表示正在吃饭
private Philosopher left; //左边的哲学家
private Philosopher right; //右边的哲学家
private String name; //记录自己的名字

public Philosopher(final String name) {
this.name = name;
}

public int getPState() {
return this.state;
}

public void setPState(final int state) {
this.state = state;
}

public void setLeft(final Philosopher philosopher) {
this.left = philosopher;
}

public Philosopher getLeft(){
return this.left;
}

public void setRight(final Philosopher philosopher) {
this.right = philosopher;
}

public Philosopher getRight(){
return this.right;
}

/**
* 判断当前是否具备吃的条件.
*/
public boolean canEat() {
//当前哲学家处于饥饿状态，而且左右两边的哲学家还没有一个人处于吃的状态，那么当前哲学家就可以吃
if(this.getPState() == 1 && this.getLeft().getPState() != 2
&& this.getRight().getPState() != 2) {
return true;
}
return false;
}

/**
* 哲学家吃饭....
*/
public synchronized void eating() {
/*ERROR： Exception Current Thread not owner，也就是wait、notify都只能在当前线程中访问，而其他线程不能访问
try { //首先堵住左右两边的哲学家进行竞争
//阻塞左边的哲学家
if(this.getLeft().getPState() == 1) {
this.getLeft().wait();
}
//阻塞右边的哲学家
if(this.getRight().getPState() == 1) {
this.getRight().wait();
}
} catch (Exception e) {
e.printStackTrace();
} */

this.setPState(2);  //将当前哲学家的状态置为2，从而阻塞左右两边的线程

//阻塞左边的哲学家
if(this.getLeft().getPState() == 1) {
this.getLeft().PEat();
}
//阻塞右边的哲学家
if(this.getRight().getPState() == 1) {
this.getRight().PEat();
}

System.out.println(this.name + " 正在吃饭....");
try{
Thread.sleep(300); // 吃饭时间0.3秒
} catch(Exception e) {
e.printStackTrace();
}
System.out.println(this.name + " 吃完了！");
this.setPState(0); // 重新回到思考问题的状态
}

/**
* 哲学家思考问题....
*/
public void thinking() {
System.out.println(this.name + "正在思考问题....");
/*ERROR: 这里有问题，因为Thread.sleep不会让出对象锁，那么很可能会造成一个问题
那就是当前对象释放了锁的同时，很快又得到了锁，从而锁住左右两边的对象，陷入死锁。
try{
Thread.sleep(1000); //哲学家思考1秒
} catch(Exception e) {
e.printStackTrace();
}  */
//这里让哲学家干点事，不然执行太快

/*#WARNING: 想通过写文件的方式，不行。因为CPU执行和文件读写是区分的。
try {
File file = new File("./question.txt");
if(!file.exists()) {
file.createNewFile();
}
FileWriter writer = new FileWriter(file);
writer.append(this.name + " 正在思考 1 + 1 = ? \n");
writer.close();
} catch (Exception e) {
e.printStackTrace();
} */

double i = 0.0;
while (i < 100000000) {
i += 0.1;
}

this.setPState(1); //思考完了以后就饿了
}

/**
* 给每一个哲学家一个信号量
*/
public synchronized void PEat() {
if(!this.canEat()) {
try {
this.wait();
} catch(Exception e) {
e.printStackTrace();
}
}
}

public synchronized void VEat() {

/*#ERROR： Exception Current Thread not owner，也就是wait、notify都只能在当前线程中访问，而其他线程不能访问
//唤醒左边的哲学家
if(this.getLeft().getPState() == 1) {
this.getLeft().notify();
}
//唤醒右边的哲学家
if(this.getRight().getPState() == 1) {
this.getRight().notify();
} */
this.notify();
}

public void run() {
while(true) {
thinking();
this.PEat();
this.eating();
//唤醒左边的哲学家
if(this.getLeft().getPState() == 1) {
this.getLeft().VEat();
}
//唤醒右边的哲学家
if(this.getRight().getPState() == 1) {
this.getRight().VEat();
}
}
}
}

public class PhilosopherEatingQuestion {
public static void main(String[] args) {
/**
* 任意时刻都只能有两个对象在吃饭。
*/
Philosopher pher1 = new Philosopher("Lao Tzu");
Philosopher pher2 = new Philosopher("Confucius");
Philosopher pher3 = new Philosopher("Plato");
Philosopher pher4 = new Philosopher("Aristotle");
Philosopher pher5 = new Philosopher("Decare");

//现在来排位置
pher1.setLeft(pher5);
pher1.setRight(pher1);

pher2.setLeft(pher1);
pher2.setRight(pher3);

pher3.setLeft(pher2);
pher3.setRight(pher4);

pher4.setLeft(pher3);
pher4.setRight(pher5);

pher5.setLeft(pher4);
pher5.setRight(pher1);

// 启动
pher1.start();
pher2.start();
pher3.start();
pher4.start();
pher5.start();
}
}