Lock和Condition实现线程同步通信

 

IT程序员开发必备-各类资源下载清单，史上最全IT资源，个人收藏总结！

   1.在等待 Condition 时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为 Condition 应该总是在一个循环中被等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。
    2.一个锁内部可以有多个Condition，即有多路等待和通知，可以参看jdk1.5提供的Lock与Condition实现的可阻塞队列的应用案例，从中除了要体味算法，还要体味面向对象的封装。在传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，必须嵌套使用多个同步监视器对象。（如果只用一个Condition，两个放的都在等，一旦一个放的进去了，那么它通知可能会导致另一个放接着往下走。）

  例子程序1:

package edu.java5.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionCommunication {

	/**
	 * 题目要求:
	 *   子线程循环10次，接着主线程循环20次，接着又回到子线程循环10次，接着再回到主线程循环20次，
	 *   如此循环50次，请写出程序。
	 * 注意：
	 *   这种情况下，condition.await()和signal()方法和this.wait()和this.notify()方法等效
	 */
	public static void main(String[] args) {
		 final Business business = new Business();
         new Thread(new Runnable() {
			@Override
			public void run() {
		        for (int i = 0; i < 50; i++) {
					business.sub(i);
				}		
			}
	     }).start();
         for (int i = 0; i < 50; i++) {
			business.main(i);
		 }
	}

}

class Business{
	private boolean bShouldSub = true;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	public  void sub(int loop){
		lock.lock();
		/**
		 * 这里while其实也可以用if替代，只不过while的安全性比if要高， 这是为了防止"虚假唤醒"的发生。
		 * 因为JVM将cpu分配给哪个线程是随机的，所以只能在线程代码块里做出处理
		 * 当不该子线程执行，则condition.wait(),子线程将对象锁让出，然后JVM再将该对象锁分配给其他线程
		 **/
		try{
			while(!bShouldSub){
				try {
					condition.await();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			for (int i = 0; i < 10; i++) {
				System.out.println("sub thread sequence of "+i+",loop of "+loop);
			}
			//子线程执行完代码后，将bShouldSub设置为false，然后唤醒在此对象监视器上等待的单个线程
			bShouldSub = false;
			condition.signal();
		}finally{
		    lock.unlock();
		}
	}
	public  void main(int loop){
		lock.lock();
		try{
			while(bShouldSub){
				try {
					condition.await();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			for (int i = 0; i < 20; i++) {
				System.out.println("main thread sequence of "+i+",loop of "+loop);
			}
			bShouldSub = true;
			condition.signal();
		}finally{
			lock.unlock();
		}
	}
	
}

例子程序2:

package edu.java5.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreeThreadConditionCommunication {

	/**
	 * 题目要求:
	 *   主线程循环10次-->子线程1循环20次-->子线程2循环30次-->主线程循环10次-->...
	 *   如此循环50个来回
	 * 注意：
	 *   在这种情况下，this.wait()和this.notify()则不能取代condition.await()和condition.singal()
	 *   这里需要使用多个Condition对象
	 */
	public static void main(String[] args) {
		 final Business business = new Business();
         new Thread(new Runnable() {
			@Override
			public void run() {
		        for (int i = 0; i < 50; i++) {
					business.sub1(i);
				}		
			}
	     }).start();
         new Thread(new Runnable() {
			@Override
			public void run() {
               for (int i = 0; i < 50; i++) {
				    business.sub2(i);
			   }				
			}
		}).start();
         for (int i = 0; i < 50; i++) {
			business.main(i);
		 }
	}

	static class Business{
		private int should = 0;
		Lock lock = new ReentrantLock();
		
		Condition condition0 = lock.newCondition();
		Condition condition1 = lock.newCondition();
		Condition condition2 = lock.newCondition();
		//主线程执行代码
		public  void main(int loop){
			lock.lock();
			try{
				while(should != 0){
					try {
						condition0.await();
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int i = 0; i < 10; i++) {
					System.out.println("main thread sequence of "+i+",loop of "+loop);
				}
				should = 1;
				condition1.signal();
			}finally{
				lock.unlock();
			}
		}
		//子线程1执行代码
		public  void sub1(int loop){
			lock.lock();
			/**
			 * 这里while其实也可以用if替代，只不过while的安全性比if要高， 这是为了防止"虚假唤醒"的发生。
			 * 因为JVM将cpu分配给哪个线程是随机的，所以只能在线程代码块里做出处理
			 * 当不该子线程执行，则condition.wait(),子线程将对象锁让出，然后JVM再将该对象锁分配给其他线程
			 **/
			try{
				while(should != 1){
					try {
						condition1.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				for (int i = 0; i < 20; i++) {
					System.out.println("sub1 thread sequence of "+i+",loop of "+loop);
				}
				//子线程执行完代码后，将bShouldSub设置为false，然后唤醒在此对象监视器上等待的单个线程
				should = 2;
				condition2.signal();
			}finally{
			    lock.unlock();
			}
		}
		//子线程2执行代码
		public  void sub2(int loop){
			lock.lock();
			/**
			 * 这里while其实也可以用if替代，只不过while的安全性比if要高， 这是为了防止"虚假唤醒"的发生。
			 * 因为JVM将cpu分配给哪个线程是随机的，所以只能在线程代码块里做出处理
			 * 当不该子线程执行，则condition.wait(),子线程将对象锁让出，然后JVM再将该对象锁分配给其他线程
			 **/
			try{
				while(should != 2){
					try {
						condition2.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				for (int i = 0; i < 30; i++) {
					System.out.println("sub2 thread sequence of "+i+",loop of "+loop);
				}
				//子线程执行完代码后，将bShouldSub设置为false，然后唤醒在此对象监视器上等待的单个线程
				should = 0;
				condition0.signal();
			}finally{
			    lock.unlock();
			}
		}
		
	}
	
}