哲学家进餐问题

//这个进餐原理:死循环拿左边的筷子,拿到之后一次机会拿右边的筷子,如果拿不到,放下左边的筷子;依次循环
public class ZXJ {
	public static void main(String[] args) {
			Chopstick k1 = new Chopstick("筷子一号");
			Chopstick k2 = new Chopstick("筷子二号");
			Chopstick k3 = new Chopstick("筷子三号");
			Chopstick k4 = new Chopstick("筷子四号");
			Chopstick k5 = new Chopstick("筷子五号");

			Philosopher p1 = new Philosopher("哲学家A", k1, k2);
			Philosopher p2 = new Philosopher("哲学家B", k2, k3);
			Philosopher p3 = new Philosopher("哲学家C", k3, k4);
			Philosopher p4 = new Philosopher("哲学家D", k4, k5);
			Philosopher p5 = new Philosopher("哲学家E", k5, k1);
			p1.start();
			p2.start();
			p3.start();
			p4.start();
			p5.start();
	}
	static class Chopstick{
		private String index;
		private boolean Enable = true;
		public Chopstick(String index){
			this.index = index;
		}
		public synchronized boolean taken(){
			if(Enable){
				Enable = false;
				return true;
			}else{
				return false;
			}
		}
		public synchronized void drop(){
			Enable=true;
			notifyAll();
		}
		@Override
		public String toString() {
			return "第"+(index)+"只筷子";
		}
		
	}
	static class Philosopher extends Thread{
		private Chopstick leftChp,rightChp;
		private String name;
		public Philosopher(String name,Chopstick leftChp,Chopstick rightChp){
			this.name = name;
			this.leftChp = leftChp;
			this.rightChp = rightChp;
		}
		public void run(){
			try {
				System.out.println(name + "在思考中。。。");
				Thread.sleep((long) (Math.random()));// 思考时间
				System.out.println(name + "思考结束！");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			while(true){
				boolean leftflag=leftChp.taken();// 左手拿筷子
				while (!leftflag) // 没有拿到就等待一段时间再拿
				{
					try {
						sleep(10);
					} catch (Exception ex) {

					}
					leftflag = leftChp.taken();
					System.out.println(name + "继续获取" +leftChp.index);
				}
				System.out.println(name + "抓起" + leftChp.index);
				
				boolean rightflag=rightChp.taken();// 右手开始拿筷子
				if(rightflag)// 拿到了，不在等待，开始吃
				{
					System.out.println(name + "抓起" + rightChp.index);
					break;
				}
				else// 没拿到，把左手已经拿到的筷子放下继续等待
				{
					System.out.println(name + "没有拿到" + rightChp.index);
					leftChp.drop();
					System.out.println(name + "放下" + leftChp.index+"继续等待...");
					try
					{
						sleep(10);
					}catch(Exception ex){}
				}
			}
			System.out.println(name + "拿到两支筷子开吃");

			try {
				Thread.sleep(1);// 吃饭时间
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(name + "吃饱之后放下了" + leftChp.index + "和" + rightChp.index+ "!");
			leftChp.drop();
			rightChp.drop();
		}
	}
/**
 * 运行结果:
 *  哲学家B在思考中。。。
	哲学家B思考结束！
	哲学家B抓起筷子二号
	哲学家B抓起筷子三号
	哲学家B拿到两支筷子开吃
	哲学家D在思考中。。。
	哲学家D思考结束！
	哲学家D抓起筷子四号
	哲学家D抓起筷子五号
	哲学家D拿到两支筷子开吃
	哲学家A在思考中。。。
	哲学家A思考结束！
	哲学家A抓起筷子一号
	哲学家A没有拿到筷子二号
	哲学家A放下筷子一号继续等待...
	哲学家C在思考中。。。
	哲学家D吃饱之后放下了筷子四号和筷子五号!
	哲学家B吃饱之后放下了筷子二号和筷子三号!
	哲学家C思考结束！
	哲学家C抓起筷子三号
	哲学家C抓起筷子四号
	哲学家C拿到两支筷子开吃
	哲学家E在思考中。。。
	哲学家E思考结束！
	哲学家E抓起筷子五号
	哲学家E抓起筷子一号
	哲学家E拿到两支筷子开吃
	哲学家C吃饱之后放下了筷子三号和筷子四号!
	哲学家E吃饱之后放下了筷子五号和筷子一号!
	哲学家A抓起筷子一号
	哲学家A抓起筷子二号
	哲学家A拿到两支筷子开吃
	哲学家A吃饱之后放下了筷子一号和筷子二号!
 */		
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
//这个进餐原理:前面四位哲学家先拿左边的筷子后拿右边的筷子;最后一个哲学家先拿右边的筷子,后拿左边的筷子
public class ZXJ1 {
	public static void main(String[] args) {
		Chopstick[] Chopsticks=new Chopstick[5];
		for(int i=0; i<5; i++){
			Chopsticks[i] = new Chopstick();
		}
		ExecutorService exec = Executors.newCachedThreadPool();
		for(int i=0; i<4; i++){
			exec.execute(new Philosopher("第"+(i+1)+"位:",Chopsticks[i],Chopsticks[i+1]));
		}
		exec.execute(new Philosopher("第5位:",Chopsticks[0],Chopsticks[4]));
		exec.shutdown();
	}
	static class Chopstick{
		private boolean taken = false;
		public synchronized void taken(){
			if(taken){
				try {
					this.wait();
				} catch (InterruptedException e) {e.printStackTrace();}
			}
			taken = true;
		}
		public synchronized void drop(){
			taken = false;
			notifyAll();
		}
	}
	static class Philosopher implements Runnable{
		private String name;
		private Chopstick left;
		private Chopstick right;
		public Philosopher(String name,Chopstick left,Chopstick right){
			this.name = name;
			this.left = left;
			this.right = right;
		}
		public void pause(){
			try {
				System.out.println(this.name+"在思考....");
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		public void run() {
			System.out.println(this.name+"准备拿起左边的筷子...");
			left.taken();
			System.out.println(this.name+"拿到左边的筷子！！！");
			System.out.println(this.name+"准备拿起右边的筷子...");
			right.taken();
			System.out.println(this.name+"拿到右边的筷子！！！");
			System.out.println("^^^^^^^"+this.name+"拿到了筷子,开始吃饭");
			pause();
			System.out.println("^^^^^^^"+this.name+"吃饭完成,准备放下筷子");
			left.drop();
			right.drop();
			System.out.println("^^^^^^^"+this.name+"放下筷子---------------------------------!!!");
		}
	}
	/**
	 * 运行结果:
	 *  第1位:准备拿起左边的筷子...
		第1位:拿到左边的筷子！！！
		第1位:准备拿起右边的筷子...
		第1位:拿到右边的筷子！！！
		^^^^^^^第1位:拿到了筷子,开始吃饭
		第1位:在思考....
		第3位:准备拿起左边的筷子...
		第3位:拿到左边的筷子！！！
		第3位:准备拿起右边的筷子...
		第3位:拿到右边的筷子！！！
		^^^^^^^第3位:拿到了筷子,开始吃饭
		第3位:在思考....
		第5位:准备拿起左边的筷子...
		第2位:准备拿起左边的筷子...
		第4位:准备拿起左边的筷子...
		^^^^^^^第1位:吃饭完成,准备放下筷子
		第5位:拿到左边的筷子！！！
		第5位:准备拿起右边的筷子...
		第5位:拿到右边的筷子！！！
		^^^^^^^第5位:拿到了筷子,开始吃饭
		第5位:在思考....
		^^^^^^^第1位:放下筷子---------------------------------!!!
		第2位:拿到左边的筷子！！！
		第2位:准备拿起右边的筷子...
		^^^^^^^第3位:吃饭完成,准备放下筷子
		第2位:拿到右边的筷子！！！
		^^^^^^^第2位:拿到了筷子,开始吃饭
		^^^^^^^第3位:放下筷子---------------------------------!!!
		第2位:在思考....
		第4位:拿到左边的筷子！！！
		第4位:准备拿起右边的筷子...
		^^^^^^^第2位:吃饭完成,准备放下筷子
		^^^^^^^第5位:吃饭完成,准备放下筷子
		^^^^^^^第2位:放下筷子---------------------------------!!!
		^^^^^^^第5位:放下筷子---------------------------------!!!
		第4位:拿到右边的筷子！！！
		^^^^^^^第4位:拿到了筷子,开始吃饭
		第4位:在思考....
		^^^^^^^第4位:吃饭完成,准备放下筷子
		^^^^^^^第4位:放下筷子---------------------------------!!!
	 */
}