/**
 * セマフォを用いた相互排除を行うプログラム
 * $ java SemaphoreMutex で実行
 */
import java.util.concurrent.Semaphore;
import java.util.Random;

/**
 * セマフォを用いた相互排除アルゴリズムを実行するクラスの
 * インスタンスを生成し実行するクラス
 * SemaphoreMutualExclusion クラスのインスタンスを4つ作り実行する
 */
class SemaphoreMutex {
	public static void main (String[] args) {
		int maxConcurrentAccess = 2;  // 同時に使える資源の数
		int threadNum = 4;            // スレッド数

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

		/* スレッドを生成する */
		Thread th[] = new Thread[threadNum];
		for (int i=0; i<th.length; ++i) { 
			th[i] = new SemaphoreMutualExclusion(i);
		}

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

/**
 * セマフォを用いた相互排除アルゴリズム実行クラス
 */
class SemaphoreMutualExclusion extends Thread {
	int threadID;         // スレッド番号
	String space;         // 表示位置調整用

	static int maxConcurrentAccess;	// 同時に使える資源の数
	static Semaphore semaphore;     // セマフォ
	static Random random = new Random(); // ランダム遅延時間発生用

	/**
	 * セマフォを生成する
	 * @param mca 同時に使える資源の数
	 */
	static void newSemaphore (int mca) {
		maxConcurrentAccess = mca;
		semaphore = new Semaphore (maxConcurrentAccess);
	}

	/**
	 * コンストラクタ
	 * @param threadNum スレッド番号
	 */
	SemaphoreMutualExclusion (int threadID) {
		/* 各フィールドに値設定 */
		this.threadID = threadID;
		space = "";                       // スレッド番号に合わせて表示位置を調整
		for (int i=0; i<threadID; ++i)
			space += "\t\t";
	}

	/**
	 * セマフォを用いた相互排除アルゴリズムの実行を繰り返す
	 */
	public void run () {
		while (true) {
			wait (semaphore);      // wait 命令
			cs();                  // 臨界領域
			signal (semaphore);    // signal 命令
			ncs();                 // 非臨界領域
		}
	}

	/**
	 * セマフォへに対して 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 命令
	}

	/**
	 * 臨界領域
	 * latencyCS() で指定した時間待機する
	 */
	void cs() {
		/* セマフォ変数(現在空いている資源の数)と共に臨界領域の開始を表示 */
		System.out.println (semaphore.availablePermits() + " : " + space + "CS begin");
		pass (latencyCS());
		System.out.println ((semaphore.availablePermits()+1) + " : " + space + "CS end");
	}

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

	/**
	 * 臨界領域の遅延時間をランダムに設定する
	 * @return 1000未満のランダムな値
	 */
	long latencyCS() {
		return (long) random.nextInt(1000);
	}

	/**
	 * 非臨界領域の遅延時間をランダムに設定する
	 * @return 5000未満のランダムな値
	 */
	long latencyNCS() {
		return (long) random.nextInt(5000);
	}

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