public class ConditionCommunication {
	public static void main(String[] args) {
		Business bussiness = new Business();
		new Thread(new Runnable() {
			// 開(kāi)啟一個(gè)子線程
			@Override
			          public void run() {
				for (int i = 1; i <= 50; i++) {
					bussiness.sub(i);
				}
			}
		}
		).start();
		// main方法主線程
		for (int i = 1; i <= 50; i++) {
			bussiness.main(i);
		}
	}
}
class Business {
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	//Condition是在具體的lock之上的
	private Boolean bShouldSub = true;
	public void sub(int i) {
		lock.lock();
		try {
			while (!bShouldSub) {
				try {
					condition.await();
					//用condition來(lái)調(diào)用await方法
				}
				catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			for (int j = 1; j <= 10; j++) {
				System.out.println("sub thread sequence of " + j
				            + ", loop of " + i);
			}
			bShouldSub = false;
			condition.signal();
			//用condition來(lái)發(fā)出喚醒信號(hào)，喚醒某一個(gè)
		}
		finally {
			lock.unlock();
		}
	}
	public void main(int i) {
		lock.lock();
		try {
			while (bShouldSub) {
				try {
					condition.await();
					//用condition來(lái)調(diào)用await方法
				}
				catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			for (int j = 1; j <= 10; j++) {
				System.out.println("main thread sequence of " + j
				            + ", loop of " + i);
			}
			bShouldSub = true;
			condition.signal();
			//用condition來(lái)發(fā)出喚醒信號(hào)么，喚醒某一個(gè)
		}
		finally {
			lock.unlock();
		}
	}
}

class Buffer {
	final Lock lock = new ReentrantLock();
	//定義一個(gè)鎖
	final Condition notFull = lock.newCondition();
	//定義阻塞隊(duì)列滿了的Condition
	final Condition notEmpty = lock.newCondition();
	//定義阻塞隊(duì)列空了的Condition
	final Object[] items = new Object[10];
	//為了下面模擬，設(shè)置阻塞隊(duì)列的大小為10，不要設(shè)太大
	int putptr, takeptr, count;
	//數(shù)組下標(biāo)，用來(lái)標(biāo)定位置的
	//往隊(duì)列中存數(shù)據(jù)
	public void put(Object x) throws InterruptedException {
		lock.lock();
		//上鎖
		try {
			while (count == items.length) {
				System.out.println(Thread.currentThread().getName() + " 被阻塞了，暫時(shí)無(wú)法存數(shù)據(jù)！");
				notFull.await();
				//如果隊(duì)列滿了，那么阻塞存數(shù)據(jù)這個(gè)線程，等待被喚醒
			}
			//如果沒(méi)滿，按順序往數(shù)組中存
			items[putptr] = x;
			if (++putptr == items.length) //這是到達(dá)數(shù)組末端的判斷，如果到了，再回到始端
			putptr = 0;
			++count;
			//消息數(shù)量
			System.out.println(Thread.currentThread().getName() + " 存好了值： " + x);
			notEmpty.signal();
			//好了，現(xiàn)在隊(duì)列中有數(shù)據(jù)了，喚醒隊(duì)列空的那個(gè)線程，可以取數(shù)據(jù)啦
		}
		finally {
			lock.unlock();
			//放鎖
		}
	}
	//從隊(duì)列中取數(shù)據(jù)
	public Object take() throws InterruptedException {
		lock.lock();
		//上鎖
		try {
			while (count == 0) {
				System.out.println(Thread.currentThread().getName() + " 被阻塞了，暫時(shí)無(wú)法取數(shù)據(jù)！");
				notEmpty.await();
				//如果隊(duì)列是空，那么阻塞取數(shù)據(jù)這個(gè)線程，等待被喚醒
			}
			//如果沒(méi)空，按順序從數(shù)組中取
			Object x = items[takeptr];
			if (++takeptr == items.length) //判斷是否到達(dá)末端，如果到了，再回到始端
			takeptr = 0;
			--count;
			//消息數(shù)量
			System.out.println(Thread.currentThread().getName() + " 取出了值： " + x);
			notFull.signal();
			//好了，現(xiàn)在隊(duì)列中有位置了，喚醒隊(duì)列滿的那個(gè)線程，可以存數(shù)據(jù)啦
			return x;
		}
		finally {
			lock.unlock();
			//放鎖
		}
	}
}

public class BoundedBuffer {
	public static void main(String[] args) {
		Buffer buffer = new Buffer();
		for (int i = 0; i < 5; i ++) {
			//開(kāi)啟5個(gè)線程往緩沖區(qū)存數(shù)據(jù)
			new Thread(new Runnable() {
				@Override
				        public void run() {
					try {
						buffer.put(new Random().nextint(1000));
						//隨機(jī)存數(shù)據(jù)
					}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			).start();
		}
		for (int i = 0; i < 10; i ++) {
			//開(kāi)啟10個(gè)線程從緩沖區(qū)中取數(shù)據(jù)
			new Thread(new Runnable() {
				@Override
				        public void run() {
					try {
						buffer.take();
						//從緩沖區(qū)取數(shù)據(jù)
					}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			).start();
		}
	}
}

public class ThreeConditionCommunication {
	public static void main(String[] args) {
		Business bussiness = new Business();
		new Thread(new Runnable() {
			// 開(kāi)啟一個(gè)子線程
			@Override
			          public void run() {
				for (int i = 1; i <= 50; i++) {
					bussiness.sub1(i);
				}
			}
		}
		).start();
		new Thread(new Runnable() {
			// 開(kāi)啟另一個(gè)子線程
			@Override
			      public void run() {
				for (int i = 1; i <= 50; i++) {
					bussiness.sub2(i);
				}
			}
		}
		).start();
		// main方法主線程
		for (int i = 1; i <= 50; i++) {
			bussiness.main(i);
		}
	}
	static class Business {
		Lock lock = new ReentrantLock();
		Condition condition1 = lock.newCondition();
		//Condition是在具體的lock之上的
		Condition condition2 = lock.newCondition();
		Condition conditionMain = lock.newCondition();
		private int bShouldSub = 0;
		public void sub1(int i) {
			lock.lock();
			try {
				while (bShouldSub != 0) {
					try {
						condition1.await();
						//用condition來(lái)調(diào)用await方法
					}
					catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 10; j++) {
					System.out.println("sub1 thread sequence of " + j
					              + ", loop of " + i);
				}
				bShouldSub = 1;
				condition2.signal();
				//讓線程2執(zhí)行
			}
			finally {
				lock.unlock();
			}
		}
		public void sub2(int i) {
			lock.lock();
			try {
				while (bShouldSub != 1) {
					try {
						condition2.await();
						//用condition來(lái)調(diào)用await方法
					}
					catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 10; j++) {
					System.out.println("sub2 thread sequence of " + j
					              + ", loop of " + i);
				}
				bShouldSub = 2;
				conditionMain.signal();
				//讓主線程執(zhí)行
			}
			finally {
				lock.unlock();
			}
		}
		public void main(int i) {
			lock.lock();
			try {
				while (bShouldSub != 2) {
					try {
						conditionMain.await();
						//用condition來(lái)調(diào)用await方法
					}
					catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 5; j++) {
					System.out.println("main thread sequence of " + j
					              + ", loop of " + i);
				}
				bShouldSub = 0;
				condition1.signal();
				//讓線程1執(zhí)行
			}
			finally {
				lock.unlock();
			}
		}
	}
}