/**
 * 相互排除アルゴリズム実行クラス
 * 実行できる相互排除アルゴリズムは以下の4種類
 * 0. 交互実行アルゴリズム
 * 1. Dekker のアルゴリズム
 * 2. Peterson のアルゴリズム
 * 3. Lamport のアルゴリズム
 */
class MutualExclusion extends Thread {
	int threadID;              // スレッド番号
	long latencyCS;            // 臨界領域の中にいる時間
	long latencyNCS;           // 非臨界領域の中にいる時間
	String spc = "";           // 行頭表示用空白
	static int threadNum = 2;  // スレッド数 (Lamport では4)
	static int turn = 0;       // 次に臨界領域に入るスレッド番号	
	static boolean flag[];     // 臨界領域への突入宣言フラグ (Deker, Peterson で使用)
	static int priority[];     // 優先順位                   (Lamport で使用)
	static boolean enter[];    // 優先順位獲得               (Lamport で使用)
	static int algorithmNum = 0;      // 実行するアルゴリズムの番号
		/* 0: 交互実行アルゴリズム
		 * 1: Dekker のアルゴリズム
		 * 2: Peterson のアルゴリズム
		 * 3: Lamport のアルゴリズム
		 */

	/**
	 * コンストラクタ
	 * @param threadID    スレッド番号
	 * @param latencyCS    臨界領域の中にいる時間(ミリ秒)
	 * @param latencyNCS   非臨界領域の中にいる時間(ミリ秒)
	 */
	MutualExclusion(int threadID, long latencyCS, long latencyNCS) {
		/* 各フィールドに値設定 */
		this.threadID = threadID;
		this.latencyCS = latencyCS;
		this.latencyNCS = latencyNCS;
		for (int i=0; i<threadID; ++i) // 行頭表示用空白をセット
			spc += "\t\t";
	}

	/**
	 * クラス変数をセットする
	 * @param thn  スレッド番号
	 * @param algn 実行するアルゴリズム番号
	 */
	static void setParameter (int thn, int algn) {
		threadNum = thn;
		algorithmNum = algn;
		flag = new boolean[threadNum];
		priority = new int[threadNum];
		enter = new boolean[threadNum];
		for (int i=0; i<threadNum; ++i) {
			flag[i] = false;
			priority[i] = 0;
			enter[i] = false;
		}
	}

	/**
	 * algorithmNum で指定した相互排除アルゴリズムの実行を繰り返す
	 */
	public void run () {
		switch (algorithmNum) {
		case 0:
			while (true) alternate(); // 交互実行アルゴリズムを繰り返す
		case 1:
			while (true) dekker();    // Dekker のアルゴリズムを繰り返す
		case 2:
			while (true) perterson(); // Peterson のアルゴリズムを繰り返す
		case 3:
			while (true) lamport();   // Lamport のアルゴリズムを繰り返す
		}
	}

	/**
	 * 交互実行アルゴリズムを実行 (スレッド数2)
	 */
	void alternate() {
		/* 相手スレッドが臨界領域を出るまで待つ */
		while (turn != threadID) pass (500L); // 0.5秒待機

		cs();                              // 臨界領域

		/* 次は相手スレッドが臨界領域に入る番 */
		if (threadID == 0) turn = 1; else turn = 0;

		ncs();                             // 非臨界領域
	}

	/**
	 * Dekker のアルゴリズムを実行 (スレッド数2)
	 */
	void dekker() {
		flag[threadID] = true;          // 臨界領域に入ると宣言

		/* 相手スレッドが臨界領域に入っているかチェック */
		while ((threadID == 0 && flag[1]) || (threadID == 1 && flag[0])) {
			if (turn != threadID) {       // 相手スレッドの番か?
				flag[threadID] = false; // 宣言を一旦取り下げ

				/* 相手スレッドが臨界領域を出るまで待つ */
				while (turn != threadID) pass (300L); // 0.3秒待機

				flag[threadID] = true;  // 再度宣言
			}
			pass (200L);                    // 0.2秒待機
		}

		cs();                              // 臨界領域

		/* 次は相手スレッドが臨界領域に入る番 */
		if (threadID == 0) turn = 1; else turn = 0;
		flag[threadID] = false;         // 宣言を取り下げ

		ncs();                             // 非臨界領域
	}

	/**
	 * Perterson のアルゴリズムを実行 (スレッド数2)
	 */
	void perterson() {
		flag[threadID] = true;          // 臨界領域に入ると宣言

		if (threadID == 0) turn = 1; else turn = 0; // 相手の番にする

		/* 相手の番かつ相手が臨界領域に入っているなら待機 */
		while ((threadID == 0 && flag[1] && turn == 1)
			|| (threadID == 1 && flag[0] && turn == 0))
			pass (500L);                   // 0.5秒待機

		cs();                              // 臨界領域

		flag[threadID] = false;            // 宣言を取り下げ

		ncs();                             // 非臨界領域
	}

	/**
	 * Lamport のアルゴリズムを実行 (スレッド数4)
	 */
	void lamport() {
		enter[threadID] = true;       // 優先順位獲得開始
		int max = 0;
		for (int i=0; i<threadNum; ++i) {
			if (max < priority[i]) max = priority[i];
		}
		priority[threadID] = max + 1; // それまでに他スレッドが得た順位+1 を得る
		enter[threadID] = false;      // 優先順位獲得完了

		for (int i=0; i<threadID; ++i) {
			while (enter[i]) pass (50L); // スレッドiが順位を得るまで待機
			while ((priority[i] != 0) && (priority[i] <= priority[threadID])) {
				pass (400L);  // 自分より順位の高いスレッドが処理を終えるまで待つ
			}
		}
		for (int i=threadID+1; i<threadNum; ++i) {
			while (enter[i]) pass (50L); // スレッドiが順位を得るまで待機
			while ((priority[i] != 0) && (priority[i] < priority[threadID])) {
				pass (400L);  // 自分より順位の高いスレッドが処理を終えるまで待つ
			}
		}
		cs();                              // 臨界領域

		priority[threadID] = 0;            // 優先順位をリセット

		ncs();                             // 非臨界領域
	}

	/**
	 * 臨界領域
	 * latencyCS で指定した時間待機する
	 */
	void cs() {
		System.out.println (spc + "Thread"+ threadID + " : CS begin");
		pass (latencyCS);
		System.out.println (spc + "Thread"+ threadID + " : CS end");
	}

	/**
	 * 非臨界領域
	 * latencyNCS で指定した時間待機する
	 */
	void ncs() {
		pass (latencyNCS);
	}

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