JAVA 并发编程-线程同步通信技术（Lock和Condition）（十）

最新推荐文章于 2022-06-29 09:22:59 发布

静静～嗯嗯

最新推荐文章于 2022-06-29 09:22:59 发布

阅读量2.6k

点赞数 1

分类专栏：多线程 JAVA java 并发多线程

本文链接：https://blog.csdn.net/hejingyuan6/article/details/47068305

版权

JAVA 同时被 3 个专栏收录

113 篇文章 1 订阅

订阅专栏

多线程

15 篇文章 0 订阅

订阅专栏

java 并发多线程

12 篇文章 62 订阅

订阅专栏

在之前的博客中已经介绍过线程同步通信技术《JAVA 并发编程-传统线程同步通信技术（四）》，上篇是使用的synchronized，wait，notify来实现，今天我们使用的是Lock和Condition，下面我们结合两者对比来学习。

简单的Lock锁应用：

/**
 * 简单Lock的应用
 * @author hejingyuan
 *
 */
public class LockTest {

	public static void main(String[] args) {
		new LockTest().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable(){
			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangxiaoxiang");
				}
				
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("lihuoming");
				}
				
			}
		}).start();
		
	}

	static class Outputer{
		Lock lock = new ReentrantLock();
		public void output(String name){
			int len = name.length();
			lock.lock();
			try{
				for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}finally{
				lock.unlock();
			}
		}
	}
}

Lock比传统线程模型中的Synchronied方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码段要实现同步互斥的效果,它们必须用同一个Lock对象,锁是在代表要操作的资源的类的内部方法中,而不是线程代码中.

注意：

和synchronized不同的是，在线程执行完以后，要关闭锁unlock(),如果不关闭，其他在等待的线程就永远被锁在外面了。因为synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否，而ReentrantLock使用代码实现的，系统无法自动释放锁，需要在代码中finally子句中显式释放锁lock.unlock();

结合前篇博客进行对比（同步通信）：

实现效果：子线程循环10次，接着主线程循环100次，又回到子线程循环10次，接着再回到主线程又循环100次，如此循环50次

public class ConditionCommunication {

	public static void main(String[] args) {
		
		final Business business = new Business();
		//创建了一个线程，并启动
		new Thread(
				new Runnable() {
					
					@Override
					public void run() {					
						for(int i=1;i<=50;i++){
							business.sub(i);
						}						
					}
				}
		).start();
		//因为mian方法本身就占用一个线程，所以主线程不需要再new Thread
		for(int i=1;i<=50;i++){
			business.main(i);
		}
		
	}

	static class Business {
		
		  Lock lock = new ReentrantLock();
		  Condition condition = lock.newCondition();
		  //决定是main执行还是sub执行
		  private boolean bShouldSub = true;
		  public  void sub(int i){
			  lock.lock();// 锁住了别的线程就不能进来了,包括下面的main()因为他们用的是同一把锁
			  try{
				  //bShouldSub==false时等待
				  while(!bShouldSub){
					  try {
						condition.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				  }
					for(int j=1;j<=10;j++){
						System.out.println("sub thread sequence of " + j + ",loop of " + i);
					}
				  bShouldSub = false;
				  condition.signal();
			  }finally{
				  lock.unlock();
			  }
		  }
		  
		  public  void main(int i){
			  lock.lock();
			  try{
				 //bShouldSub==true时等待
				 while(bShouldSub){
				  		try {
							condition.await();
						} catch (Exception e) {
							e.printStackTrace();
						}
				  	}
					for(int j=1;j<=100;j++){
						System.out.println("main thread sequence of " + j + ",loop of " + i);
					}
					bShouldSub = true;
					condition.signal();
		  }finally{
			//如果中途抛出异常,那么这把锁就没有被解锁,别人就进不来了
			//所以写在finally里面
			  lock.unlock();
		  }
	  }
	
	}
}

在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现。

Condition实例实质上被绑定到一个锁上。要为特定Lock实例获得Condition 实例，请使用其newCondition() 方法。

注意：在等待Condition时,可能会发生"虚假唤醒"。

虚假唤醒(spuriouswakeup)在采用条件等待时，我们使用的是

while(条件不满足){

condition_wait(cond, mutex);

}

而不是:

If( 条件不满足 ){

Condition_wait(cond,mutex);

}

这是因为可能会存在虚假唤醒”spuriouswakeup”的情况。

也就是说，即使没有线程调用condition_signal,原先调用condition_wait的函数也可能会返回。此时线程被唤醒了，但是条件并不满足，这个时候如果不对条件进行检查而往下执行，就可能会导致后续的处理出现错误。

在系统设计时应该可以避免虚假唤醒，但是这会影响条件变量的执行效率，而既然通过while循环就能避免虚假唤醒造成的错误，因此程序的逻辑就变成了while循环的情况。

Condition可以控制多个线程之间的运行顺序

Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，这样可以控制多个线程之间的运行顺序。

例如：

应当先对线程1、线程2，建 condition对象 1： c_th1，对象 2: c_th2;

c_th1.await() // 阻塞写线程1

c_th2.signal() // 唤醒读线程2

-------

否则，多线程时，函数没有参数时，如何指定阻塞哪个，唤醒哪个呢，线程可能多于2个，总要有方法指定。

实现demo(有三个线程，想让线程1运行完以后运行线程2，线程2运行完以后运行线程3，线程3运行完以后又运行线程1):

public class ThreeConditionCommunication {

	public static void main(String[] args) {
		
		final Business business = new Business();
		new Thread(
				new Runnable() {
					
					@Override
					public void run() {
					
						for(int i=1;i<=50;i++){
							business.sub2(i);
						}
						
					}
				}
		).start();
		
		new Thread(
				new Runnable() {
					
					@Override
					public void run() {
					
						for(int i=1;i<=50;i++){
							business.sub3(i);
						}
						
					}
				}
		).start();		
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
		
	}

	static class Business {
		  Lock lock = new ReentrantLock();
		  Condition condition1 = lock.newCondition();
		  Condition condition2 = lock.newCondition();
		  Condition condition3 = lock.newCondition();
		  private int shouldSub = 1;
		  public  void sub2(int i){
			  lock.lock();
			  try{
				  while(shouldSub != 2){
					  try {
						condition2.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				  }
					for(int j=1;j<=10;j++){
						System.out.println("sub2 thread sequence of " + j + ",loop of " + i);
					}
				  shouldSub = 3;
				  condition3.signal();
			  }finally{
				  lock.unlock();
			  }
		  }

		  public  void sub3(int i){
			  lock.lock();
			  try{
				  while(shouldSub != 3){
					  try {
						condition3.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				  }
					for(int j=1;j<=20;j++){
						System.out.println("sub3 thread sequence of " + j + ",loop of " + i);
					}
				  shouldSub = 1;
				  condition1.signal();
			  }finally{
				  lock.unlock();
			  }
		  }		  
		  
		  public  void main(int i){
			  lock.lock();
			  try{
				 while(shouldSub != 1){
				  		try {
							condition1.await();
						} catch (Exception e) {
							e.printStackTrace();
						}
				  	}
					for(int j=1;j<=100;j++){
						System.out.println("main thread sequence of " + j + ",loop of " + i);
					}
					shouldSub = 2;
					condition2.signal();
		  }finally{
			  lock.unlock();
		  }
	  }
	
	}
}

总结：

对于以上的两种实现线程同步通信的方式，Lock替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。而对比来说Lock（本身为一个对象）更加面向对象，Condition可以为多个线程间建立不同的Condition，这样可以控制多个线程之间的运行顺序。