条件阻塞Condition的应用

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

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * 题目：子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，主线程循环100次，
 * 如此循环50次
 *
 */
publicclass ConditionCommunicate {
 
   publicstaticvoid main(String[] args) {
     
      Business business = new Business();
     
      new Thread(new Runnable(){
         @Override
         publicvoid run() {
            for(inti= 0 ; i< 50 ; i++){
                business.sub(i);
            }
         }
      }).start();
     
     
      for(inti= 0 ; i< 50 ; i++){
         business.main(i);
      }
   }
  
   publicvoid init(){
   }
 
 
   /**
    * 这个类是内部类，但用static修饰相当于外部类，他的名称是：ConditionCommunicate.Business
    */
   staticclass Business{
     
      Lock lock = new ReentrantLock();
      Condition condition = lock.newCondition();
      privatebooleanbShouldSub = true;
     
      publicvoid sub(inti){
         lock.lock();
         try{
            while(!bShouldSub){
                try {
                   condition.await();//使用condition替换原来的wait
//                 this.wait(); //wait和notify必须在synchronized内部使用
                } catch (Exception e) {
                   e.printStackTrace();
                }
            }
           
            for(intj = 0 ; j< 10; j++){
                System.out.println("sub Thread cycle of "+ j +", loop of "+ i);
            }
           
            bShouldSub = false;
            condition.signal();//使用condition替换原来的notify
//          this.notify();
         }finally{
            lock.unlock();
         }
      }
     
      publicvoid main(inti){
         lock.lock();
         try{
            //这里while要比if好，会防止伪唤醒。
            while(bShouldSub){
                try {
//                 this.wait();
                   condition.await();
                } catch (Exception e) {
                   e.printStackTrace();
                }
            }
            for(intj = 0 ; j< 5; j++){
                System.out.println("main Thread cycle of "+ j +", loop of "+ i);
            }
           
            bShouldSub = true;
//          this.notify();
            condition.signal();
         }finally{
            lock.unlock();
         }
      }
   }
 
}
 

用到多个Condition

在java jdk 的Condition中有这样的一个阻塞队列的例子：

      假定有一个绑定的缓冲区，它支持  put 和  take 方法。如果试图在空的缓冲区上执行  take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行  put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存  put 线程和  take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个  Condition 实例来做到这一点。

class BoundedBuffer {
      final Lock lock = new ReentrantLock();
      final Condition notFull  = lock.newCondition();
      final Condition notEmpty = lock.newCondition();
 
      final Object[] items = new Object[100];
      intputptr, takeptr, count;
 
      publicvoid 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();
          returnx;
        } finally {
          lock.unlock();
        }
      }
 }

三个线程循环走（用到三个Condition）：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * 题目：子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，主线程循环100次，
 * 如此循环50次
 * 在此题目上改进，有三个线程，老大先走，老大走完老二走，老二走完老三走。这样循环
 * 这样就要用到多个Condition条件
 *  老大唤醒老二需要condition、老二唤醒老三需要condition、老三唤醒老大需要condition。所以需要
 *  三个condition
 */
publicclass ThreeConditionCommunicate {
 
   publicstaticvoid main(String[] args) {
     
      Business business = new Business();
     
      new Thread(new Runnable(){
         @Override
         publicvoid run() {
            for(inti= 0 ; i< 50 ; i++){
                business.sub2(i);
            }
         }
      }).start();
     
      new Thread(new Runnable(){
         @Override
         publicvoid run() {
            for(inti= 0 ; i< 50 ; i++){
                business.sub3(i);
            }
         }
      }).start();
     
     
      for(inti= 0 ; i< 50 ; i++){
         business.main(i);
      }
   }
  
   publicvoid init(){
   }
 
 
   /**
    * 这个类是内部类，但用static修饰相当于外部类，他的名称是：ConditionCommunicate.Business
    */
   staticclass Business{
     
      Lock lock = new ReentrantLock();
      Condition condition1 = lock.newCondition();
      Condition condition2 = lock.newCondition();
      Condition condition3 = lock.newCondition();
     
      privateintshouldSub = 1;
     
      publicvoid sub2(inti){
         lock.lock();
         try{
            while(shouldSub != 2){
                try {
                   condition2.await();
//                 this.wait(); //wait和notify必须在synchronized内部使用
                } catch (Exception e) {
                   e.printStackTrace();
                }
            }
           
            for(intj = 0 ; j< 10; j++){
                System.out.println("sub2 Thread cycle of "+ j +", loop of "+ i);
            }
           
            shouldSub = 3;
            condition3.signal();
//          this.notify();
         }finally{
            lock.unlock();
         }
      }
     
      publicvoid sub3(inti){
         lock.lock();
         try{
            while(shouldSub != 3){
                try {
                   condition3.await();
//                 this.wait(); //wait和notify必须在synchronized内部使用
                } catch (Exception e) {
                   e.printStackTrace();
                }
            }
           
            for(intj = 0 ; j< 4; j++){
                System.out.println("sub3 Thread cycle of "+ j +", loop of "+ i);
            }
           
            shouldSub = 1;
            condition1.signal();
//          this.notify();
         }finally{
            lock.unlock();
         }
      }
     
      publicvoid main(inti){
         lock.lock();
         try{
            //这里while要比if好，会防止伪唤醒。
            while(shouldSub != 1){
                try {
//                 this.wait();
                   condition1.await();
                } catch (Exception e) {
                   e.printStackTrace();
                }
            }
            for(intj = 0 ; j< 5; j++){
                System.out.println("main Thread cycle of "+ j +", loop of "+ i);
            }
           
            shouldSub = 2;
//          this.notify();
            condition2.signal();
         }finally{
            lock.unlock();
         }
      }
   }
 
}