條件阻塞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();
         }
      }
   }
 
}