Condition实现线程通信

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

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

 

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

 static 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 (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();
     }finally{
      lock.unlock();
     }
    }
   
    public  void main(int i){
     lock.lock();
     try{
     while(bShouldSub){
        try {
       condition.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);
     }
     bShouldSub = true;
     condition.signal();
    }finally{
     lock.unlock();
    }
   }
 
 }

 

 

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) {
      // 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){
     lock.lock();
     try{
     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();
    }
   }
 
 }