這篇文章將為大家詳細(xì)講解有關(guān)java并發(fā)等待條件的示例分析，小編覺得挺實(shí)用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

為眉山等地區(qū)用戶提供了全套網(wǎng)頁設(shè)計制作服務(wù)，及眉山網(wǎng)站建設(shè)行業(yè)解決方案。主營業(yè)務(wù)為成都網(wǎng)站建設(shè)、成都做網(wǎng)站、眉山網(wǎng)站設(shè)計，以傳統(tǒng)方式定制建設(shè)網(wǎng)站，并提供域名空間備案等一條龍服務(wù)，秉承以專業(yè)、用心的態(tài)度為用戶提供真誠的服務(wù)。我們深信只要達(dá)到每一位用戶的要求，就會得到認(rèn)可，從而選擇與我們長期合作。這樣，我們也可以走得更遠(yuǎn)！

前言

前面介紹了排它鎖，共享鎖的實(shí)現(xiàn)機(jī)制，本篇繼續(xù)學(xué)習(xí)AQS中的另外一個內(nèi)容-Condition。想必學(xué)過java的都知道Object.wait和Object.notify，同時也應(yīng)該知曉這兩個方法的使用離不開synchronized關(guān)鍵字。synchronized是jvm級別提供的同步原語，它的實(shí)現(xiàn)機(jī)制隱藏在jvm實(shí)現(xiàn)中。作為Lock系列功能中的Condition，就是用來實(shí)現(xiàn)類似 Object.wait和Object.notify 對應(yīng)功能的。

使用場景

為了更好的理解Lock和Condition的使用場景，下面我們先來實(shí)現(xiàn)這樣一個功能：有多個生產(chǎn)者，多個消費(fèi)者，一個產(chǎn)品容器，我們假設(shè)容器最多可以放3個產(chǎn)品，如果滿了，生產(chǎn)者需要等待產(chǎn)品被消費(fèi)，如果沒有產(chǎn)品了，消費(fèi)者需要等待。我們的目標(biāo)是一共生產(chǎn)10個產(chǎn)品，最終消費(fèi)10個產(chǎn)品，如何在多線程環(huán)境下完成這一挑戰(zhàn)呢？下面是我簡單實(shí)現(xiàn)的一個demo，僅供參考。

package com.lock.condition.test;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class LockConditionTest {
  // 生產(chǎn) 和 消費(fèi) 的最大總數(shù)
  public static int totalCount = 10;
  // 已經(jīng)生產(chǎn)的產(chǎn)品數(shù)
  public static volatile int hasProduceCount = 0;
  // 已經(jīng)消費(fèi)的產(chǎn)品數(shù)
  public static volatile int hasConsumeCount = 0;
  // 容器最大容量
  public static int containerSize = 3;
  // 使用公平策略的可重入鎖，便于觀察演示結(jié)果
  public static ReentrantLock lock = new ReentrantLock(true);
  public static Condition notEmpty = lock.newCondition();
  public static Condition notFull = lock.newCondition();
  // 容器
  public static LinkedList container = new LinkedList();
  // 用于標(biāo)識產(chǎn)品
  public static AtomicInteger idGenerator = new AtomicInteger();
  public static void main(String[] args) {
    Thread p1 = new Thread(new Producer(), "p-1");
    Thread p2 = new Thread(new Producer(), "p-2");
    Thread p3 = new Thread(new Producer(), "p-3");
    Thread c1 = new Thread(new Consumer(), "c-1");
    Thread c2 = new Thread(new Consumer(), "c-2");
    Thread c3 = new Thread(new Consumer(), "c-3");
    c1.start();
    c2.start();
    c3.start();
    p1.start();
    p2.start();
    p3.start();
    try{
      c1.join();
      c2.join();
      c3.join();
      p1.join();
      p2.join();
      p3.join();
    }catch(Exception e){
    }
    System.out.println(" done. ");
  }
  static class Producer implements Runnable{
    @Override
    public void run() {
      while(true){
        lock.lock();
        try{
          // 容器滿了，需要等待非滿條件
          while(container.size() >= containerSize){
            notFull.await();
          }
          // 到這里表明容器未滿，但需要再次判斷是否已經(jīng)完成了任務(wù)
          if(hasProduceCount >= totalCount){
            System.out.println(Thread.currentThread().getName()+" producer exit");
            return ;
          }
          int product = idGenerator.incrementAndGet();
          // 把生產(chǎn)出來的產(chǎn)品放入容器
          container.addLast(product);
          System.out.println(Thread.currentThread().getName() + " product " + product);
          hasProduceCount++;
          // 通知消費(fèi)線程可以去消費(fèi)了
          notEmpty.signal();
        } catch (InterruptedException e) {
        }finally{
          lock.unlock();
        }
      }
    }
  }
  static class Consumer implements Runnable{
    @Override
    public void run() {
      while(true){
        lock.lock();
        try{
          if(hasConsumeCount >= totalCount){
            System.out.println(Thread.currentThread().getName()+" consumer exit");
            return ;
          }
          // 一直等待有產(chǎn)品了，再繼續(xù)往下消費(fèi)
          while(container.isEmpty()){
            notEmpty.await(2, TimeUnit.SECONDS);
            if(hasConsumeCount >= totalCount){
              System.out.println(Thread.currentThread().getName()+" consumer exit");
              return ;
            }
          }
          Integer product = container.removeFirst();
          System.out.println(Thread.currentThread().getName() + " consume " + product);
          hasConsumeCount++;
          // 通知生產(chǎn)線程可以繼續(xù)生產(chǎn)產(chǎn)品了
          notFull.signal();
        } catch (InterruptedException e) {
        }finally{
          lock.unlock();
        }
      }
    }
  }
}

一次執(zhí)行結(jié)果如下：

p-1 product 1
p-3 product 2
p-2 product 3
c-3 consume 1
c-2 consume 2
c-1 consume 3
p-1 product 4
p-3 product 5
p-2 product 6
c-3 consume 4
c-2 consume 5
c-1 consume 6
p-1 product 7
p-3 product 8
p-2 product 9
c-3 consume 7
c-2 consume 8
c-1 consume 9
p-1 product 10
p-3 producer exit
p-2 producer exit
c-3 consume 10
c-2 consumer exit
c-1 consumer exit
p-1 producer exit
c-3 consumer exit
 done.

從結(jié)果可以發(fā)現(xiàn)已經(jīng)達(dá)到我們的目的了。

深入理解Condition的實(shí)現(xiàn)原理

上面的示例只是為了展示 Lock結(jié)合Condition可以實(shí)現(xiàn)的一種經(jīng)典場景，在有了感性的認(rèn)識之后，我們將一步一步來觀察Lock和Condition是如何協(xié)作完成這一任務(wù)的，這也是本篇的核心內(nèi)容。

為了更好的理解和演示這一個過程，我們使用到的鎖是使用公平策略模式的，我們會使用上面例子運(yùn)作的流程。我們會使用到3個生產(chǎn)線程，3個消費(fèi)線程，分別表示 p1、p2、p3和c1、c2、c3。

Condition的內(nèi)部實(shí)現(xiàn)是使用節(jié)點(diǎn)鏈來實(shí)現(xiàn)的，每個條件實(shí)例對應(yīng)一個節(jié)點(diǎn)鏈，我們有notEmpty 和 notFull 兩個條件實(shí)例，所以會有兩個等待節(jié)點(diǎn)鏈。

一切準(zhǔn)備就緒 ，開始我們的探索之旅。

1、線程c3執(zhí)行，然后發(fā)現(xiàn)沒有產(chǎn)品可以消費(fèi)，執(zhí)行 notEmpty.await，進(jìn)入等待隊列中等候。

2、線程c2和線程c1執(zhí)行，然后發(fā)現(xiàn)沒有產(chǎn)品可以消費(fèi)，執(zhí)行 notEmpty.await，進(jìn)入等待隊列中等候。

3、 線程 p1 啟動，得到了鎖，p1開始生產(chǎn)產(chǎn)品，這時候p3搶在p2之前，執(zhí)行了lock操作，結(jié)果p2和p3都處于等待狀態(tài)，入同步隊列等待。<喎?"/kf/ware/vc/" target="_blank" class="keylink">vcD4NCjxwPjxpbWcgYWx0PQ=="這里寫圖片描述" src="/uploadfile/Collfiles/20160912/20160912092710536.png" title="\" />

注意，本例中我們使用的是公平策略模式下的排它鎖，由于p3搶先執(zhí)行取鎖操作，所以雖然p2和p3都被阻塞了，但是p3會優(yōu)先被喚醒 。

4、這會，p1生產(chǎn)完畢，通知 not empty等待隊列，可以喚醒一個等待線程節(jié)點(diǎn)了，然后釋放了鎖，釋放鎖會導(dǎo)致p3被喚醒，然后p1進(jìn)入下一個循環(huán)，進(jìn)入同步隊列。

事情開始變得有趣了，p1執(zhí)行一次生產(chǎn)后，執(zhí)行了 notEmpty.signal，其效果就是把 not empty等待列表中的頭節(jié)點(diǎn)，即c3節(jié)點(diǎn)移到同步等待列隊中，重新參與搶占鎖。

5、p3生產(chǎn)完了產(chǎn)品后，繼續(xù)notEmpty.signal，同時釋放鎖，釋放鎖后會喚醒p2線程，然后p3在下一輪嘗試獲取鎖的時候，再次入隊。

6、接著，p2繼續(xù)生產(chǎn)，生產(chǎn)后執(zhí)行 notEmpty.signal，同時釋放鎖，釋放鎖后喚醒c3線程，然后p2在下一輪嘗試取鎖的時候，入列。

7、c3進(jìn)行消費(fèi)，你可以看到，現(xiàn)在 not empty等待列隊中已經(jīng)沒有等待節(jié)點(diǎn)了，由于我們使用的是公平策略排它鎖，這就會導(dǎo)致同步隊列中的節(jié)點(diǎn)一個接著一個執(zhí)行，而目前同步隊列中的節(jié)點(diǎn)排列為一生產(chǎn)，一消費(fèi)，這不難可以知道，接下來代碼已經(jīng)不會進(jìn)入 wait條件了，所以一個一個輪流執(zhí)行就是，比如c3，執(zhí)行完了，繼續(xù)notFull.signal(); 然后釋放鎖，入隊，這里要明白，notFull.signal();這句代碼其實(shí)沒有作用了，因為 not full等待隊列中沒有任何等待線程節(jié)點(diǎn)。 c3執(zhí)行后，狀態(tài)如下圖所示：

關(guān)于“java并發(fā)等待條件的示例分析”這篇文章就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，使各位可以學(xué)到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。