快捷導(dǎo)航

Java多線程編程中使用Condition類操作鎖的方法詳解

更新時(shí)間：2016年07月11日 08:59:28 作者：三千分之一的愛

Condition是java.util.concurrent.locks包下的類,提供了對(duì)線程鎖的更精細(xì)的控制方法,下面我們就來看一下Java多線程編程中使用Condition類操作鎖的方法詳解

Condition的作用是對(duì)鎖進(jìn)行更精確的控制。Condition中的await()方法相當(dāng)于Object的wait()方法，Condition中的signal()方法相當(dāng)于Object的notify()方法，Condition中的signalAll()相當(dāng)于Object的notifyAll()方法。不同的是，Object中的wait(),notify(),notifyAll()方法是和"同步鎖"(synchronized關(guān)鍵字)捆綁使用的；而Condition是需要與"互斥鎖"/"共享鎖"捆綁使用的。

Condition函數(shù)列表

// 造成當(dāng)前線程在接到信號(hào)或被中斷之前一直處于等待狀態(tài)。
void await()
// 造成當(dāng)前線程在接到信號(hào)、被中斷或到達(dá)指定等待時(shí)間之前一直處于等待狀態(tài)。
boolean await(long time, TimeUnit unit)
// 造成當(dāng)前線程在接到信號(hào)、被中斷或到達(dá)指定等待時(shí)間之前一直處于等待狀態(tài)。
long awaitNanos(long nanosTimeout)
// 造成當(dāng)前線程在接到信號(hào)之前一直處于等待狀態(tài)。
void awaitUninterruptibly()
// 造成當(dāng)前線程在接到信號(hào)、被中斷或到達(dá)指定最后期限之前一直處于等待狀態(tài)。
boolean awaitUntil(Date deadline)
// 喚醒一個(gè)等待線程。
void signal()
// 喚醒所有等待線程。
void signalAll()

Condition類用法示例
Condition 將 Object 監(jiān)視器方法（wait、notify 和 notifyAll）分解成截然不同的對(duì)象，以便通過將這些對(duì)象與任意 Lock 實(shí)現(xiàn)組合使用，為每個(gè)對(duì)象提供多個(gè)等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監(jiān)視器方法的使用。下面將之前寫過的一個(gè)線程通信的例子替換成用Condition實(shí)現(xiàn)，代碼如下：

public class ThreadTest2 { 
  public static void main(String[] args) { 
    final Business business = new Business(); 
    new Thread(new Runnable() { 
      @Override 
      public void run() { 
        threadExecute(business, "sub"); 
      } 
    }).start(); 
    threadExecute(business, "main"); 
  }   
  public static void threadExecute(Business business, String threadType) { 
    for(int i = 0; i < 100; i++) { 
      try { 
        if("main".equals(threadType)) { 
          business.main(i); 
        } else { 
          business.sub(i); 
        } 
      } catch (InterruptedException e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 
class Business { 
  private boolean bool = true; 
  private Lock lock = new ReentrantLock(); 
  private Condition condition = lock.newCondition();  
  public /*synchronized*/ void main(int loop) throws InterruptedException { 
    lock.lock(); 
    try { 
      while(bool) {         
        condition.await();//this.wait(); 
      } 
      for(int i = 0; i < 100; i++) { 
        System.out.println("main thread seq of " + i + ", loop of " + loop); 
      } 
      bool = true; 
      condition.signal();//this.notify(); 
    } finally { 
      lock.unlock(); 
    } 
  }   
  public /*synchronized*/ void sub(int loop) throws InterruptedException { 
    lock.lock(); 
    try { 
      while(!bool) { 
        condition.await();//this.wait(); 
      } 
      for(int i = 0; i < 10; i++) { 
        System.out.println("sub thread seq of " + i + ", loop of " + loop); 
      } 
      bool = false; 
      condition.signal();//this.notify(); 
    } finally { 
      lock.unlock(); 
    } 
  } 
}

在Condition中，用await()替換wait()，用signal()替換notify()，用signalAll()替換notifyAll()，傳統(tǒng)線程的通信方式，Condition都可以實(shí)現(xiàn)，這里注意，Condition是被綁定到Lock上的，要?jiǎng)?chuàng)建一個(gè)Lock的Condition必須用newCondition()方法。
這樣看來，Condition和傳統(tǒng)的線程通信沒什么區(qū)別，Condition的強(qiáng)大之處在于它可以為多個(gè)線程間建立不同的Condition，下面引入API中的一段代碼，加以說明。

class BoundedBuffer { 
  final Lock lock = new ReentrantLock();//鎖對(duì)象 
  final Condition notFull = lock.newCondition();//寫線程條件  
  final Condition notEmpty = lock.newCondition();//讀線程條件  
 
  final Object[] items = new Object[100];//緩存隊(duì)列 
  int putptr/*寫索引*/, takeptr/*讀索引*/, count/*隊(duì)列中存在的數(shù)據(jù)個(gè)數(shù)*/; 
 
  public void put(Object x) throws InterruptedException { 
   lock.lock(); 
   try { 
    while (count == items.length)//如果隊(duì)列滿了  
     notFull.await();//阻塞寫線程 
    items[putptr] = x;//賦值  
    if (++putptr == items.length) putptr = 0;//如果寫索引寫到隊(duì)列的最后一個(gè)位置了，那么置為0 
    ++count;//個(gè)數(shù)++ 
    notEmpty.signal();//喚醒讀線程 
   } finally { 
    lock.unlock(); 
   } 
  } 
 
  public Object take() throws InterruptedException { 
   lock.lock(); 
   try { 
    while (count == 0)//如果隊(duì)列為空 
     notEmpty.await();//阻塞讀線程 
    Object x = items[takeptr];//取值  
    if (++takeptr == items.length) takeptr = 0;//如果讀索引讀到隊(duì)列的最后一個(gè)位置了，那么置為0 
    --count;//個(gè)數(shù)-- 
    notFull.signal();//喚醒寫線程 
    return x; 
   } finally { 
    lock.unlock(); 
   } 
  }  
 }

這是一個(gè)處于多線程工作環(huán)境下的緩存區(qū)，緩存區(qū)提供了兩個(gè)方法，put和take，put是存數(shù)據(jù)，take是取數(shù)據(jù)，內(nèi)部有個(gè)緩存隊(duì)列，具體變量和方法說明見代碼，這個(gè)緩存區(qū)類實(shí)現(xiàn)的功能：有多個(gè)線程往里面存數(shù)據(jù)和從里面取數(shù)據(jù)，其緩存隊(duì)列(先進(jìn)先出后進(jìn)后出)能緩存的最大數(shù)值是100，多個(gè)線程間是互斥的，當(dāng)緩存隊(duì)列中存儲(chǔ)的值達(dá)到100時(shí)，將寫線程阻塞，并喚醒讀線程，當(dāng)緩存隊(duì)列中存儲(chǔ)的值為0時(shí)，將讀線程阻塞，并喚醒寫線程，下面分析一下代碼的執(zhí)行過程：
1. 一個(gè)寫線程執(zhí)行，調(diào)用put方法；

2. 判斷count是否為100，顯然沒有100；

3. 繼續(xù)執(zhí)行，存入值；

4. 判斷當(dāng)前寫入的索引位置++后，是否和100相等，相等將寫入索引值變?yōu)?，并將count+1；
5. 僅喚醒讀線程阻塞隊(duì)列中的一個(gè)；

6. 一個(gè)讀線程執(zhí)行，調(diào)用take方法；

7. ……

8. 僅喚醒寫線程阻塞隊(duì)列中的一個(gè)。

這就是多個(gè)Condition的強(qiáng)大之處，假設(shè)緩存隊(duì)列中已經(jīng)存滿，那么阻塞的肯定是寫線程，喚醒的肯定是讀線程，相反，阻塞的肯定是讀線程，喚醒的肯定是寫線程，那么假設(shè)只有一個(gè)Condition會(huì)有什么效果呢，緩存隊(duì)列中已經(jīng)存滿，這個(gè)Lock不知道喚醒的是讀線程還是寫線程了，如果喚醒的是讀線程，皆大歡喜，如果喚醒的是寫線程，那么線程剛被喚醒，又被阻塞了，這時(shí)又去喚醒，這樣就浪費(fèi)了很多時(shí)間。

您可能感興趣的文章: