java5条件阻塞Condition的应用-多路等待通知Lock-Condition使用-笔记整理10

于 2017-04-23 15:31:29 发布
阅读量1.7k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： java多线程系列 文章标签： 条件阻塞Condition
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Mark2When/article/details/70500302
本文详细介绍Java中Condition接口的应用，包括如何利用Condition实现多线程间的同步与等待，对比传统Object类的wait和notify方法，展示Condition在多路等待通知场景的优势。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

java5条件阻塞Condition的应用

Condition的功能类似在传统线程技术中的Object.wait和Object.notify的功能。在等待Condition时，允许发生”虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为Condition应该总是在一个循环中被等待，并测试正在等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

一个锁内部可以有多个Condition，即有多路等待和通知，可以参看jdk1.5提供的Lock与Condition实现的可阻塞队列的应用案例，从中除了要体会算法，还要体会面向对象的封装。在传统的线程机制中一个监视对象上只能由一路等待和通知，要实现多路等待和通知，必须嵌套使用多个同步监视器对象。(如果只用一个Condition，两个放的都在等，一旦一个放的进去了，那么它通知可能会导致另一个放接着往下走。)


大纲：

(1)用面试宝典中的子线程循环10次和主线程循环5次，两者交替运行50的例子进行讲解。 

(2)参考jdk文档中，Condition对象api中官方给了一种多路等待的阻塞队列代码 

 (3)在子线程和主线程交替循环时候，再加入一个线程，3个线程间交替执行，1执行完通知2,2执行完通知3，3执行完通知1（使用多个Condition来解决多路等待通知）


(1)用面试宝典中的子线程循环10次和主线程循环5次，两者交替运行50的例子进行讲解。

传统方式，使用synchronized来实现线程间互斥，Object自带的this.wait()、this.notify()实现线程间互斥

Jdk1.5之后使用Lock的lock()、unlock()方法实现线程间互斥，Lock.newCondition()的await()、signal()方法来实现线程间的同步


代码示例1：传统方式，使用synchronized来实现线程间互斥，Object自带的this.wait()、this.notify()实现线程间互斥

public class TraditionalThreadCommunication2 {

	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();
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
		
	}

}
  class Business {
	  
	  private boolean bShouldSub = true;
	  public synchronized void sub(int i){
		  while(!bShouldSub){
			  try {
				this.wait();
			} catch (InterruptedException 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;
		  this.notify();
	  }
	  
	  public synchronized void main(int i){
			  while(bShouldSub){
			  		try {
						this.wait();
			  		} catch (InterruptedException e) {
						e.printStackTrace();
					}
			  	}
				for(int j=1;j<=100;j++){
					System.out.println("main thread sequence of " + j + ",loop of " + i);
				}
				this.notify();
				bShouldSub = true;
	  }
  }


代码示例2：Jdk1.5之后使用Lock的lock()、unlock()方法实现线程间互斥，Lock.newCondition()的await()、signal()方法来实现线程间的同步

注意使用的是：condition的await()、signal()方法。而不是wait()、notify()方法，这俩个方法都是Object对象中的，是每个对象都有的，要用condition对象自由的等待、唤醒方法。

遇到过一个问题，为什么要将线程的等待，唤醒方法用放到Object祖先类中？

考虑到，所有的类都会被用到锁对象，结合synchronized的原理，其内部都是一个锁对象和一个监听(condition)对象.

                在使用synchronized关键字，其默认的锁对象和监听对象默认是同一个。在synchronized中使用唤醒、等待方法，要使用所对应锁对象的wait()、notify()方法。

 在使用的锁对象代码块中，使用的等待、唤醒方法 不是锁对象对应的监听对象的方法，会报错误：java.lang.IllegalMonitorStateException



public class TraditionalThreadCommunication {

	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();
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
		
	}

}
  class Business {
	  Lock lock=new ReentrantLock();
	  Condition condition=lock.newCondition();
	  
	  private boolean bShouldSub = true;
	  
	  public void sub(int i){
		  lock.lock();
		  try {
			  while(!bShouldSub){
				  try {
					condition.await();
				  } catch (InterruptedException 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 {
			  while(bShouldSub){
			  		try {
						//this.wait();
						condition.await();
			  		} catch (InterruptedException 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 {
			lock.unlock();
		  }
	  }
}



(2)参考jdk文档中，Condition对象api中官方给了一种多路等待的阻塞队列代码 

通过俩个Condition对象来操作缓冲阻塞队列里的数据，

在存放数据的方法中，通过notFull(Condition)来控制操作线程等待，唤醒 取数据 线程

在取数据的方法中，通过notEmpty(Condition)来控制操作线程等待，唤醒 存数据 线程

如果只使用一个Condition来控制线程间的存取，线程之间的唤醒是随机唤醒，如果唤醒的都是取线程（或读线程）会产生死锁

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length) 
         notFull.await();
       items[putptr] = x; 
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0) 
         notEmpty.await();
       Object x = items[takeptr]; 
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   } 
 }

 (3)在子线程和主线程交替循环时候，再加入一个线程，3个线程间交替执行，1执行完通知2,2执行完通知3，3执行完通知1（使用多个Condition来解决多路等待通知）

通过3个 Condition 和 shouldSub的三个状态 是来同步线程间的等待唤醒次序关系

public class TreeConditionCommunication {

	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 {
	  private int shouldSub = 1;
	   Lock  lock = new ReentrantLock();
	  Condition condition1 = lock.newCondition();
	  Condition condition2 = lock.newCondition();
	  Condition condition3 = lock.newCondition();
	  public  void sub2(int i){		  
		  
		  lock.lock();
		  try{
		  while(shouldSub!=2){
			  try {
				condition2.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);
			}
		  shouldSub = 3;
		  condition3.signal();
		  }
		  finally{
			   lock.unlock();
		  }
		 
	  }
 public  void sub3(int i){		  
		  
		  lock.lock();
		  try{
		  while(shouldSub!=3){
			  try {
				condition3.await();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				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){
		  try{
			  lock.lock();
		  	while(shouldSub!=1){
		  		try {
					condition1.await();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					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();
		  }
	  }
  }
}




评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值