前面我們已經(jīng)分析過JUC包里面的Lock鎖，ReentrantLock鎖和semaphore信號量機(jī)制。Lock鎖實(shí)現(xiàn)了比synchronized更靈活的鎖機(jī)制，Reentrantlock是Lock的實(shí)現(xiàn)類，是一種可重入鎖，都是每次只有一次線程對資源進(jìn)行處理；semaphore實(shí)現(xiàn)了多個(gè)線程同時(shí)對一個(gè)資源的訪問；今天我們要講的ReadWriteLock鎖將實(shí)現(xiàn)另外一種很重要的功能：讀寫分離鎖。

假設(shè)你的程序中涉及到對一些共享資源的讀和寫操作，且寫操作沒有讀操作那么頻繁。在沒有寫操作的時(shí)候，兩個(gè)線程同時(shí)讀一個(gè)資源沒有任何問題，所以應(yīng)該允許多個(gè)線程能在同時(shí)讀取共享資源。但是如果有一個(gè)線程想去寫這些共享資源，就不應(yīng)該再有其它線程對該資源進(jìn)行讀或?qū)?，也就是說：讀-讀能共存，讀-寫不能共存，寫-寫不能共存。這就需要一個(gè)讀/寫鎖來解決這個(gè)問題。

ReadWriteLock簡介

我們在JUC包可以看到ReadWriteLock是一個(gè)接口，他有一個(gè)實(shí)現(xiàn)類：ReentrantReadWriteLock，先讓我們對讀寫訪問資源的條件做個(gè)概述：

• - 讀?。?沒有線程正在做寫操作，且沒有線程在請求寫操作。
• - 寫入： 沒有線程正在做讀寫操作。
  

如果某個(gè)線程想要讀取資源，只要沒有線程正在對該資源進(jìn)行寫操作且沒有線程請求對該資源的寫操作即可。同樣當(dāng)有線程想要寫資源，但是此刻有線程正在讀取資源，那么此刻寫資源的操作是不能繼續(xù)下去的。

我們來看一個(gè)例子:

public class ReadWriteLockTest2 {
  public static void main(String[] args) {
      final int threadCount = 2;
      final ExecutorService exService = Executors.newFixedThreadPool(threadCount);
      final ScoreBoard scoreBoard = new ScoreBoard();
      exService.execute(new ScoreUpdateThread(scoreBoard));
      exService.execute(new ScoreHealthThread(scoreBoard));
      exService.shutdown();
    }
  }

  class ScoreBoard {
    private boolean scoreUpdated = false;
    private int score = 0;
    String health = "不可用";
    final ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();

    public String getMatchHealth() {
      rrwl.readLock().lock();
      if (scoreUpdated) {
        rrwl.readLock().unlock();
        rrwl.writeLock().lock();
        try {
          if (scoreUpdated) {
            score = fetchScore();
            scoreUpdated = false;
          }
          rrwl.readLock().lock();
        } finally {
          rrwl.writeLock().unlock();
        }
      }
      try {
        if (score % 2 == 0) {
          health = "Bad Score";
        } else {
          health = "Good Score";
        }
      } finally {
        rrwl.readLock().unlock();
      }
      return health;
    }

    public void updateScore() {
      try {
        rrwl.writeLock().lock();
        scoreUpdated = true;
      } finally {
        rrwl.writeLock().unlock();
      }
    }

    private int fetchScore() {
      Calendar calender = Calendar.getInstance();
      return calender.get(Calendar.MILLISECOND);
    }
  }

  class ScoreHealthThread implements Runnable {
    private ScoreBoard scoreBoard;
    public ScoreHealthThread(ScoreBoard scoreTable) {
      this.scoreBoard = scoreTable;
    }
    @Override
    public void run() {
      for(int i= 0; i< 5; i++) {
        System.out.println("Match Health: "+ scoreBoard.getMatchHealth());
        try {
          Thread.sleep(2000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  class ScoreUpdateThread implements Runnable {
    private ScoreBoard scoreBoard;
    public ScoreUpdateThread(ScoreBoard scoreTable) {
      this.scoreBoard = scoreTable;
    }
    @Override
    public void run() {
      for(int i= 0; i < 5; i++) {
        System.out.println("Score Updated.");
        scoreBoard.updateScore();
        try {
          Thread.sleep(2000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

打印結(jié)果：

Score Updated.
Match Health: Good Score
Score Updated.
Match Health: Good Score
Score Updated.
Match Health: Good Score
Score Updated.
Match Health: Good Score
Score Updated.
Match Health: Good Score

基本用法見上例，讀寫分離鎖很好的控制了多個(gè)線程對同一個(gè)資源的訪問。

ReentrantReadWriteLock

由名字我們可以看到讀寫鎖也有可重入的實(shí)現(xiàn)類。ReentrantReadWriteLock具有關(guān)聯(lián)的讀取和寫入鎖定，可以重新獲取鎖定。它可表現(xiàn)為公平和不公平的模式兩者。 默認(rèn)行為是不公平的。 非公平鎖的性能更好，雖然有可能讀寫器或?qū)懭肫麈i可以被推遲許多次，并且持續(xù)地嘗試鎖定。 在公平鎖定的情況下，鎖定請求按照最長等待的單個(gè)寫入器鎖或讀取鎖定組請求的順序來完成，無論誰具有最長等待時(shí)間將獲得對共享資源的鎖定。 在重入ReentrantReadWriteLock可以寫入鎖定降級讀鎖。 這意味著如果線程已經(jīng)獲得寫鎖定，它可以將其鎖從寫降級到讀鎖。 順序?qū)⑹鞘紫全@得寫鎖定，執(zhí)行寫操作，然后獲取讀鎖，然后解鎖寫鎖，并且在讀操作后最終解鎖讀鎖。

ReentrantReadWriteLock 也是基于 AbstractQueuedSynchronizer 實(shí)現(xiàn)的，它具有下面這些屬性：

• 獲取順序
  

此類不會將讀取者優(yōu)先或?qū)懭胝邇?yōu)先強(qiáng)加給鎖訪問的排序。但是，它確實(shí)支持可選的公平 策略。

1.非公平模式（默認(rèn)）

當(dāng)非公平地（默認(rèn)）構(gòu)造時(shí)，未指定進(jìn)入讀寫鎖的順序，受到 reentrancy 約束的限制。連續(xù)競爭的非公平鎖可能無限期地推遲一個(gè)或多個(gè) reader 或 writer 線程，但吞吐量通常要高于公平鎖。

2.公平模式

當(dāng)公平地構(gòu)造線程時(shí)，線程利用一個(gè)近似到達(dá)順序的策略來爭奪進(jìn)入。當(dāng)釋放當(dāng)前保持的鎖時(shí)，可以為等待時(shí)間最長的單個(gè) writer 線程分配寫入鎖，如果有一組等待時(shí)間大于所有正在等待的 writer 線程 的 reader 線程，將為該組分配寫入鎖。

如果保持寫入鎖，或者有一個(gè)等待的 writer 線程，則試圖獲得公平讀取鎖（非重入地）的線程將會阻塞。直到當(dāng)前最舊的等待 writer 線程已獲得并釋放了寫入鎖之后，該線程才會獲得讀取鎖。當(dāng)然，如果等待 writer 放棄其等待，而保留一個(gè)或更多 reader 線程為隊(duì)列中帶有寫入鎖自由的時(shí)間最長的 waiter，則將為那些 reader 分配讀取鎖。

試圖獲得公平寫入鎖的（非重入地）的線程將會阻塞，除非讀取鎖和寫入鎖都自由（這意味著沒有等待線程）。（注意，非阻塞 ReentrantReadWriteLock.ReadLock.tryLock() 和 ReentrantReadWriteLock.WriteLock.tryLock() 方法不會遵守此公平設(shè)置，并將獲得鎖（如果可能），不考慮等待線程）。

• 重入

此鎖允許 reader 和 writer 按照 ReentrantLock 的樣式重新獲取讀取鎖或?qū)懭腈i。在寫入線程保持的所有寫入鎖都已經(jīng)釋放后，才允許重入 reader 使用它們。

此外，writer 可以獲取讀取鎖，但反過來則不成立。在其他應(yīng)用程序中，當(dāng)在調(diào)用或回調(diào)那些在讀取鎖狀態(tài)下執(zhí)行讀取操作的方法期間保持寫入鎖時(shí)，重入很有用。如果 reader 試圖獲取寫入鎖，那么將永遠(yuǎn)不會獲得成功。

• 鎖降級
  

重入還允許從寫入鎖降級為讀取鎖，其實(shí)現(xiàn)方式是：先獲取寫入鎖，然后獲取讀取鎖，最后釋放寫入鎖。但是，從讀取鎖升級到寫入鎖是不可能的。

• 鎖獲取的中斷
  

讀取鎖和寫入鎖都支持鎖獲取期間的中斷。

• Condition 支持
  

寫入鎖提供了一個(gè) Condition 實(shí)現(xiàn)，對于寫入鎖來說，該實(shí)現(xiàn)的行為與 ReentrantLock.newCondition() 提供的 Condition 實(shí)現(xiàn)對 ReentrantLock 所做的行為相同。當(dāng)然，此 Condition 只能用于寫入鎖。讀取鎖不支持 Condition，readLock().newCondition() 會拋出 UnsupportedOperationException。

• 監(jiān)測
  

此類支持一些確定是保持鎖還是爭用鎖的方法。這些方法設(shè)計(jì)用于監(jiān)視系統(tǒng)狀態(tài)，而不是同步控制。

此類行為的序列化方式與內(nèi)置鎖的相同：反序列化的鎖處于解除鎖狀態(tài)，無論序列化該鎖時(shí)其狀態(tài)如何。

下面的代碼展示了如何利用重入來執(zhí)行升級緩存后的鎖降級（為簡單起見，省略了異常處理）：

class CachedData {
    Object data;
    volatile boolean cacheValid;
    ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
       rwl.readLock().lock();
       if (!cacheValid) {
        // 在獲得寫鎖之前必須釋放讀鎖
        rwl.readLock().unlock();
        rwl.writeLock().lock();
        // Recheck state because another thread might have acquired
        //  write lock and changed state before we did.
        if (!cacheValid) {
         data = ...
         cacheValid = true;
        }
        //通過在釋放寫鎖之前獲得讀鎖來降級
        rwl.readLock().lock();
        rwl.writeLock().unlock(); // 解鎖寫鎖，但是任然持有讀鎖
       }

      use(data);
      rwl.readLock().unlock();
    }
  }

與互斥鎖對比

互斥鎖一次只允許一個(gè)線程訪問共享數(shù)據(jù)，哪怕進(jìn)行的是只讀操作；讀寫鎖允許對共享數(shù)據(jù)進(jìn)行更高級別的并發(fā)訪問：對于寫操作，一次只有一個(gè)線程（write線程）可以修改共享數(shù)據(jù)，對于讀操作，允許任意數(shù)量的線程同時(shí)進(jìn)行讀取。

與互斥鎖相比，使用讀寫鎖能否提升性能則取決于讀寫操作期間讀取數(shù)據(jù)相對于修改數(shù)據(jù)的頻率，以及數(shù)據(jù)的爭用——即在同一時(shí)間試圖對該數(shù)據(jù)執(zhí)行讀取或?qū)懭氩僮鞯木€程數(shù)。

以上就是java并發(fā)編程專題（七）----（JUC）ReadWriteLock的用法的詳細(xì)內(nèi)容，更多關(guān)于JAVA （JUC）ReadWriteLock的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論