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

关注

原创最新推荐文章于 2026-08-28 10:05:45 发布 1.8k 阅读 AI 写同款· GEO 优化 ›

Java面试30天突击：从八股文到AI大模型应用的全栈攻略在Java后端开发领域，构建完整的知识体系是应对技术面试和工程实践的核心。其原理在于将计算机科学的基础概念（如数据结构、并发模型、内存管理）与分布式系统设计原则相结合，形成解决复杂问题的能力框架。这一技术价值体现在能够设计高可用、可扩展的系统架构，并高效处理实际业务场景中的性能与一致性挑战。随着技术演进，应用场景已从传统的Web服务扩展到需要集成AI能力（如大模型应用）的智能系统。本文聚焦于Java面试准备，提供一份为期30天的系统性学习路径，特别涵盖了当前热门的AI大模型应用开发（如Spring AI集成阅读详情

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个 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();
		  }
	  }
  }
}