Lock物件Condition介面實現等待/通知

關鍵字Synchronized與wait()和notify()/notifyAll()方法相結合可以實現等待通知，ReentrantLock藉助Condition物件可以實現同樣的功能，而且一個lock物件可以建立多個condition物件，從而能夠選擇性condition物件進行等待/通知

condition物件實現等待通知的簡單案例

public class ConditionLockDemo {
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public void csleep(){
		try{
			lock.lock();
			System.out.println(Thread.currentThread().getName()+"current time :"+System.currentTimeMillis());
			condition.await();
			System.out.println(Thread.currentThread().getName()+"喚醒後 current time :"+System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void signal(){
		try{
			lock.lock();
			condition.signal();
		}finally{
			lock.unlock();
		}
	}
}

啟動兩個執行緒，分別呼叫兩個方法

public static void main(String[] args) throws InterruptedException {
	final ConditionLockDemo cl = new ConditionLockDemo();
	Thread a = new Thread(new Runnable() {
		@Override
		public void run() {
			cl.csleep();
		}
	}, "A");
	Thread b = new Thread(new Runnable() {
		@Override
		public void run() {
			cl.signal();
		}
	}, "B");
	a.start();
	Thread.sleep(1000);
	b.start();
}

輸出:

Acurrent time :1525329885799
A喚醒後 current time :1525329886799

從這個簡單案例：

*  condition 物件是lock物件進行建立的，而且一個lock物件可以建立多個condition物件

*  等待通知的實現，藉助condition 物件的await()方法進入阻塞狀態釋放鎖，signal方法喚醒waiting的執行緒

*  await()和signal方法的呼叫必須都要先在獲取到鎖之後(lock.lock())

condition實現生產者消費者模型

3個執行緒輪流列印1,2,3 。。。

思想：

3個執行緒，建立3個condition物件

3個執行緒讀取同一個共享變數的值，然後根據值，判斷是否進入阻塞狀態

，如果不是阻塞狀態，修改這個值，並喚醒下一個執行緒,  A-B-C-A輪流喚醒

public class ThreeConditionDemo {
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();
	private volatile int count = 1;
	public void printA() {
		try{
			lock.lock();
			while(count!=1){
				condition1.await();
			}
			Thread.sleep(1000);
			System.out.println("1");
			count = 2 ;
			condition2.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void printB(){
		try{
			lock.lock();
			while(count!=2){
				condition2.await();
			}
			Thread.sleep(1000);
			System.out.println("2");
			count = 3;
			condition3.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void printC(){
		try{
			lock.lock();
			while(count!=3){
				condition3.await();
			}
			Thread.sleep(1000);
			System.out.println("3");
			count = 1;
			condition1.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}

啟動三個執行緒測試：

public static void main(String[] args) {
		final ThreeConditionDemo tcd = new ThreeConditionDemo();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					tcd.printA();
				}
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					tcd.printB();
				}
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					tcd.printC();
				}
			}
		});
		t1.start();
		t2.start();
		t3.start();
	}