package com.cxt.Lock;

import com.cxt.thread.Synchronizer;
import com.cxt.thread.TestLock;

//lock implementation with nested monitor lockout problem
/**
 * 一個坑爹的巢狀管程鎖死，區別於死鎖
 */
public class Lock {
	protected MonitorObject monitorObject = new MonitorObject();
	protected boolean isLocked = false;

	public static void main(String[] args) {
		Lock l = new Lock();
		l.isLocked = true;

		MyRunnable r1 = new MyRunnable(l, 0);
		MyRunnable r2 = new MyRunnable(l, 0);
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);
		t1.start();
		t2.start();
		/*
		 * 時而鎖住，時而釋放，因為另外兩條執行緒沒有有時捕捉不到isLocked = false
		 */
//		for (int i = 0; i < 100; i++) {
//			l.isLocked = false;
//			try {
//				Thread.sleep(10);
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			}
//		}
		//

	}

	public void lock() throws InterruptedException {
		// 當執行這個方法時，isLocked=true時,其他方法無論執行lock方法還是執行Unlock方法都會導致管程死鎖
		// 只有手動將isLocked 設定為false才能解決死鎖，設定為false時必須讓其他執行緒檢測到，所以必須設定時間長一點
		synchronized (this) {
			while (isLocked) {
				synchronized (this.monitorObject) {
					this.monitorObject.wait();
				}
			}
			isLocked = true;
		}
	}

	public void unlock() {
		synchronized (this) {
			this.isLocked = false;
			synchronized (this.monitorObject) {
				this.monitorObject.notify();
			}
		}
	}

	static class MyRunnable implements Runnable {
		Lock l = null;
		int i;

		public MyRunnable(Lock l, int i) {
			this.l = l;
			this.i = i;
		}

		@Override
		public void run() {
			try {
				if (i % 2 == 0) {
					this.l.lock();
				} else {
					this.l.unlock();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}