/**
 * セマフォを用いた食事をする哲学者問題を実行するプログラム
 * 引数 1 を付けて実行すると 解法1 :「繋がったフォーク」に、
 * 引数 2 を付けて実行すると 解法2 :「左利きの哲学者」に、
 * 引数 3 を付けて実行すると 解法3 :「我慢する哲学者」に、
 * それ以外は「デッドロックに無策な哲学者」になる
 * $ java DiningPhilosophers   → デッドロックに無策な哲学者
 * $ java DiningPhilosophers 1 → 繋がったフォーク
 * $ java DiningPhilosophers 2 → 左利きの哲学者
 * $ java DiningPhilosophers 3 → 我慢する哲学者
 */

import java.util.concurrent.Semaphore;
import java.util.Random;

/**
 * セマフォを用いた食事をする哲学者問題実行クラスの
 * インスタンスを生成し実行するクラス
 * Phlosophers クラスのインスタンスを5つ作り実行する
 */
public class DiningPhilosophers {
	public static void main(String[] args) {
		int numOfPhilosophers = 5;  // 哲学者の人数

		/* オプションの確認 
		 * 1: 繋がったフォーク
		 * 2: 左利きの哲学者
		 * 3: 我慢する哲学者
		 * それ以外: デッドロックに無策な哲学者 */
		int philosopherType = 0;
		if (args.length >= 1) {
			if (args[0].equals("1")) philosopherType = 1;
			else if (args[0].equals("2")) philosopherType = 2;
			else if (args[0].equals("3")) philosopherType = 3;
		}

		/* 哲学者のタイプを設定 */
		Philosophers.setPhilosopherType (philosopherType);

		/* セマフォを生成する */
		Philosophers.newSemaphore (numOfPhilosophers);

		/* スレッドを生成する */
		Thread ph[] = new Thread[numOfPhilosophers];
		for (int i=0; i<numOfPhilosophers; ++i) {
			ph[i] = new Philosophers(i); // 哲学者iを生成
		}

		switch (philosopherType) {
		case 1:
			System.out.println("解法1: 繋がったフォーク");
			break;
		case 2:
			System.out.println("解法2: 左利きの哲学者");
			break;
		case 3:
			System.out.println("解法3: 我慢する哲学者");
			break;
		default:
			System.out.println("デッドロックに無策な哲学者");
			break;
		}

		/* スレッドの実行開始 */
		for (int i=0; i<numOfPhilosophers; ++i) {
			ph[i].start();
		}
	}
}

/**
 * セマフォを用いた食事をする哲学者問題実行クラス
 */
class Philosophers extends Thread {
	static int numOfPhilosophers = 5;  // 哲学者の人数
	static Semaphore fork[];           //フォーク
	static Random random = new Random();             // ランダム遅延時間発生用
	static int philosopherType = 0;  // 哲学者の行動タイプ
		/* type 0 : デッドロックに無策な哲学者 */ 
		/* type 1 : 解法 : 繋がったフォーク */
		/* type 2 : 解法 : 左利きの哲学者 */
		/* type 3 : 解法 : 我慢する哲学者 */

	int PhilosopherID;   // 哲学者番号
	int rightFork;       // 右のフォーク番号
	int leftFork;        // 左のフォーク番号
	String space;        // 表示位置調整用

	/**
	 * 哲学者の行動タイプを設定
	 * @param type : 哲学者のタイプ
	 */
	static public void setPhilosopherType (int type) {
		philosopherType = type;
	}

	/**
	 * セマフォを生成する
	 * @param pn 哲学者の人数
	 */
	static void newSemaphore (int pn) {
		numOfPhilosophers = pn;	// 哲学者の人数
		fork = new Semaphore [numOfPhilosophers];
		for (int i=0; i<numOfPhilosophers; ++i) {
			fork[i] = new Semaphore (1);  // 人数分のフォークを生成
		}
	}

	/**
	 * コンストラクタ
	 * @param PhilosopherID 哲学者番号
	 */
	Philosophers (int PhilosopherID) {
		/* 各フィールドに値設定 */
		this.PhilosopherID = PhilosopherID;
		rightFork = PhilosopherID;
		leftFork = (PhilosopherID+1) % numOfPhilosophers;
		space = "";
		for (int i=0; i<PhilosopherID; ++i) space += "\t";
	}

	/**
	 * 哲学者の動作
	 * 哲学者は食事と思索を繰り返す
	 */
	public void run () {
		switch (philosopherType) {
		case 1:					// 解法1: 繋がったフォーク
			philosopher1();
			break;
		case 2:					// 解法2: 左利きの哲学者
			philosopher2();
			break;
		case 3:					// 解法3: 我慢する哲学者
			philosopher3();
			break;
		default:				// デッドロックに無策な哲学者
			philosopher0();
			break;
		}
	}

	/**
	 * デッドロックに無策な哲学者
	 */
	void philosopher0 () {
		while (true) {
			think();						// 思索

			getRightFork();					// 右のフォークを確保
			getLeftFork();					// 左のフォークを確保
			eat();							// 食事
			releaseLeftFork();				// 左のフォークを解放
			releaseRightFork();				// 右のフォークを解放
		}
	}

	/**
	 * 解法1: 繋がったフォーク
	 */
	void philosopher1 () {
		while (true) {
			think();						// 思索
			
			getAllForks();					// 全てのフォークを確保
			eat();							// 食事
			releaseAllForks();				// 全てのフォークを解放
		}
	}

	/**
	 * 解法2: 左利きの哲学者
	 */
	void philosopher2 () {
		if (PhilosopherID == 0) {
			while (true) {
				think();						// 思索

				getLeftFork();				// 左のフォークを確保
				getRightFork();				// 右のフォークを確保
				eat();						// 食事
				releaseRightFork();			// 右のフォークを解放 */
				releaseLeftFork();			// 左のフォークを解放 */
			}
		} else {
			while (true) {
				think();					// 思索

				getRightFork();				// 右のフォークを確保
				getLeftFork();				// 左のフォークを確保
				eat();						// 食事
				releaseLeftFork();			// 左のフォークを解放
				releaseRightFork();			// 右のフォークを解放
			}
		}
	}

	/**
	 * 解法3: 我慢する哲学者
	 */
	void philosopher3 () {
		while (true) {
			think();						// 思索

			getRightFork();					// 右のフォークを確保
			while (!tryGetLeftFork()) {		// 左のフォークを確保できるまで繰り返す
				releaseRightFork();			// 右のフォークを一旦解放
				pass (latencyWait());		// 少し待つ
				getRightFork();				// 右のフォークを再確保
			}
			eat();							// 食事
			releaseLeftFork();				// 左のフォークを解放
			releaseRightFork();				// 右のフォークを解放
		}
	}

	/**
	 * 右のフォークを確保する
	 */
	void getRightFork() {
		wait (fork[rightFork]);				// セマフォへの wait 命令
		System.out.println (showForks() + space + "get " + rightFork);
		pass (latencyGet());
	}

	/**
	 * 左のフォークを確保する
	 */
	void getLeftFork() {
		wait (fork[leftFork]);				// セマフォへの wait 命令
		System.out.println (showForks() + space + "get " + leftFork);
		pass (latencyGet());
	}

	/**
	 * 全てのフォークを確保する
	 */
	void getAllForks() {
		wait (fork[0]);						// セマフォへの wait 命令
		System.out.println (showForks() + space + "get all");
		pass (latencyGet());
	}

	/**
	 * 左のフォークを確保しようとする
	 * @return フォークを確保できたか否か
	 */
	boolean tryGetLeftFork() {
		boolean getFork;
		getFork = tryAndWait (fork[leftFork]);	// セマフォへの try&wait 命令
		if (getFork) {
			System.out.println (showForks() + space + "get " + leftFork);
			pass (latencyGet());
		}
		return getFork;
	}

	/**
	 * 右のフォークを解放する
	 */
	void releaseRightFork() {
		signal (fork[rightFork]);		// セマフォへの signal 命令
		System.out.println (showForks() + space + "release " + rightFork);
	}

	/**
	 * 左のフォークを解放する
	 */
	void releaseLeftFork() {
		signal (fork[leftFork]);		// セマフォへの signal 命令
		System.out.println (showForks() + space + "release " + leftFork);
	}

	/**
	 * 全てのフォークを解放する
	 */
	void releaseAllForks() {
		signal (fork[0]);				// セマフォへの signal 命令
		System.out.println (showForks() + space + "release all");
	}

	/**
	 * 哲学者が食事をする
	 */
	void eat () {
		System.out.println (showForks() + space + "eat");
		pass (latencyEat());
	}

	/**
	 * 哲学者が思索する
	 */
	void think () {
		pass (latencyThink());
	}

	/**
	 * 現在のフォークの状態を文字列として得る
	 * テーブルの上にフォークがある場合はその番号を、無い場合は空白を返す
	 */
	String showForks() {
		String forks = "";
		if (philosopherType == 1) { /* 解法1の場合 */
			if (fork[0].availablePermits() == 1) {
				for (int i=0; i<numOfPhilosophers; ++i)
					forks += i + " ";
			} else {
				for (int i=0; i<numOfPhilosophers; ++i)
					forks += "  ";
			}
		} else {
			for (int i=0; i<numOfPhilosophers; ++i) {
				if (fork[i].availablePermits() == 1)
					forks += i + " ";
				else forks += "  ";
			}
		}
		forks += " :\t";
		return forks;
	}

	/**
	 * セマフォへに対して wait 命令を出す
	 * @param semaphore セマフォ
	 */
	void wait (Semaphore semaphore) {
		try {
			semaphore.acquire();		// セマフォへの wait 命令
		} catch (InterruptedException error_report) {
			System.out.println (error_report);
			System.exit (1);
		}
	}

	/**
	 * セマフォへに対して signal 命令を出す
	 * @param semaphore セマフォ
	 */
	void signal (Semaphore semaphore) {
		semaphore.release();			// セマフォへの signal 命令
	}

	/**
	 * セマフォへに対して try&wait 命令を出す
	 * @param semaphore セマフォ
	 * @return セマフォに対する wait 命令を出せたかどうか
	 */
	boolean tryAndWait (Semaphore semaphore) {
		return semaphore.tryAcquire();	// セマフォへの try&wait 命令
	}

	/**
	 * 食事時間をランダムに設定する
	 * @return 500未満のランダムな値
	 */
	long latencyEat() {
		return (long) random.nextInt(500);
	}

	/**
	 * 思索時間をランダムに設定する
	 * @return 2000未満のランダムな値
	 */
	long latencyThink() {
		return (long) random.nextInt(2000);
	}

	/**
	 * フォークの空き待ち時間をランダムに設定する
	 * @return 500未満のランダムな値
	 */
	long latencyWait() {
		return (long) random.nextInt(500);
	}

	/**
	 * フォークの確保に掛かる時間をランダムに設定する
	 * @return 1000未満のランダムな値
	 */
	long latencyGet() {
		return (long) random.nextInt(1000);
	}

	/**
	 * 指定した時間待機する
	 * @param latency 待機する時間(ミリ秒)
	 */
	void pass (long latency) {
		try {
			sleep (latency);	// Threadのメソッド 指定したミリ秒の間一時停止する
		} catch (InterruptedException error_report) {
			System.out.println (error_report);
			System.exit (1);
		}
	}
}