日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯網營銷解決方案
我們聊一聊可重入鎖特別重要的話題

本文轉載自微信公眾號「三太子敖丙」，作者三太子敖丙 。轉載本文請聯系三太子敖丙公眾號。

創(chuàng)新互聯堅持“要么做到，要么別承諾”的工作理念，服務領域包括：成都網站制作、成都網站建設、企業(yè)官網、英文網站、手機端網站、網站推廣等服務，滿足客戶于互聯網時代的黃巖網站設計、移動媒體設計的需求，幫助企業(yè)找到有效的互聯網解決方案。努力成為您成熟可靠的網絡建設合作伙伴！

使用Java進行多線程開發(fā)，使用鎖是一個幾乎不可避免的問題。今天，就讓我們來聊一聊這個基礎，但是又特別特別重要的話題。

首先，讓我們來看一下，到底什么是鎖? 以及，為什么要使用鎖?

如果有2個線程，需要訪問同一個對象User。一個讀線程，一個寫線程。User對象有2個字段，一個是名字，一個是手機號碼。

 

當User對象剛剛創(chuàng)建出來的時候，姓名和手機號碼都是空。然后，寫線程開始填充數據。最后，就出現了以下令人心碎的一幕：

 

可以看到，雖然寫線程先于讀線程工作，但是， 由于寫姓名和寫電話號碼兩個操作不是原子的。這就導致讀線程只讀取了半個數據，在讀線程看來，User對象的電話號碼是不存在。

為了避免類似的問題，我們就需要使用鎖。讓寫線程在修改對象前，先加鎖，然后完成姓名和電話號碼的賦值，再釋放鎖。而讀線程也是一樣，先取得鎖，再讀，然后釋放鎖。這樣就可以避免發(fā)生這種情況。

如下圖所示：

 

什么是重入鎖?

好了，現在大家知道我們?yōu)槭裁匆褂面i了。那什么是重入鎖呢。通常情況下，鎖可以用來控制多線程的訪問行為。那對于同一個線程，如果連續(xù)兩次對同一把鎖進行l(wèi)ock，會怎么樣了?對于一般的鎖來說，這個線程就會被永遠卡死在那邊，比如：

  
 
 
 
    
   
  
  
  
  1. void handle() { 
    2. 
   
  
  
  
  2.     lock(); 
    3. 
   
  
  
  
  3.     lock();  //和上一個lock()操作同一個鎖對象，那么這里就永遠等待了 
    4. 
   
  
  
  
  4.     unlock(); 
    5. 
   
  
  
  
  5.     unlock(); 
    6. 
   
  
  
  
  6. } 
    7.

這個特性相當不好用，因為在實際的開發(fā)過程中，函數之間的調用關系可能錯綜復雜，一個不小心就可能在多個不同的函數中，反復調用lock()，這樣的話，線程就自己和自己卡死了。

所以，對于希望傻瓜式編程的我們來說，重入鎖就是用來解決這個問題的。重入鎖使得同一個線程可以對同一把鎖，在不釋放的前提下，反復加鎖，而不會導致線程卡死。因此，如果我們使用的是重入鎖，那么上述代碼就 可以正常工作。你唯一需要保證的，就是unlock()的次數和lock()一樣多。這樣是不是方便很多呢?

Java中的重入鎖

Java中的鎖都來自與Lock接口，如下圖中紅框內的，就是重入鎖。

 

重入鎖提供的最重要的方法就是lock()

  • void lock()：加鎖，如果鎖已經被別人占用了，就無限等待。

這個lock()方法，提供了鎖最基本的功能，拿到鎖就返回，拿不到就等待。因此，大規(guī)模得在復雜場景中使用，是有可能因此死鎖的。因此，使用這個方法得非常小心。

如果要預防可能發(fā)生的死鎖，可以嘗試使用下面這個方法:

  • boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException：嘗試獲取鎖，等待timeout時間。同時，可以響應中斷。

這是一個比單純lock()更具有工程價值的方法，如果大家閱讀過JDK的一些內部代碼，就不難發(fā)現，tryLock()在JDK內部被大量的使用。

與lock()相比,tryLock()至少有下面一個好處：

  1. 可以不用進行無限等待。直接打破形成死鎖的條件。如果一段時間等不到鎖，可以直接放棄，同時釋放自己已經得到的資源。這樣，就可以在很大程度上，避免死鎖的產生。因為線程之間出現了一種謙讓機制
  2. 可以在應用程序這層進行進行自旋，你可以自己決定嘗試幾次，或者是放棄。
  3. 等待鎖的過程中可以響應中斷，如果此時，程序正好收到關機信號，中斷就會觸發(fā)，進入中斷異常后，線程就可以做一些清理工作，從而防止在終止程序時出現數據寫壞，數據丟失等悲催的情況。

當然了，當鎖使用完后，千萬不要忘記把它釋放了。不然，程序可能就會崩潰啦~

  • void unlock() ：釋放鎖

此外， 重入鎖還有一個不帶任何參數的tryLock()。

  • public boolean tryLock()

這個不帶任何參數的tryLock()不會進行任何等待，如果能夠獲得鎖，直接返回true，如果獲取失敗，就返回false，特別適合在應用層自己對鎖進行管理，在應用層進行自旋等待。

重入鎖的實現原理

重入鎖內部實現的主要類如下圖：

 

重入鎖的核心功能委托給內部類Sync實現，并且根據是否是公平鎖有FairSync和NonfairSync兩種實現。這是一種典型的策略模式。

實現重入鎖的方法很簡單，就是基于一個狀態(tài)變量state。這個變量保存在AbstractQueuedSynchronizer對象中

  
 
 
 
    
   
  
  
  
  1. private volatile int state; 
    2.

當這個state==0時，表示鎖是空閑的，大于零表示鎖已經被占用， 它的數值表示當前線程重復占用這個鎖的次數。因此，lock()的最簡單的實現是：

  
 
 
 
    
   
  
  
  
  1. final void lock() { 
    2. 
   
  
  
  
  2. // compareAndSetState就是對state進行CAS操作，如果修改成功就占用鎖 
    3. 
   
  
  
  
  3. if (compareAndSetState(0, 1)) 
    4. 
   
  
  
  
  4.     setExclusiveOwnerThread(Thread.currentThread()); 
    5. 
   
  
  
  
  5. else 
    6. 
   
  
  
  
  6. //如果修改不成功，說明別的線程已經使用了這個鎖，那么就可能需要等待 
    7. 
   
  
  
  
  7.     acquire(1); 
    8.

下面是acquire() 的實現：

  
 
 
 
    
   
  
  
  
  1. public final void acquire(int arg) { 
    2. 
   
  
  
  
  2. //tryAcquire() 再次嘗試獲取鎖， 
    3. 
   
  
  
  
  3. //如果發(fā)現鎖就是當前線程占用的，則更新state，表示重復占用的次數， 
    4. 
   
  
  
  
  4. //同時宣布獲得所成功,這正是重入的關鍵所在 
    5. 
   
  
  
  
  5. if (!tryAcquire(arg) && 
    6. 
   
  
  
  
  6.     // 如果獲取失敗，那么就在這里入隊等待 
    7. 
   
  
  
  
  7.     acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 
    8. 
   
  
  
  
  8.     //如果在等待過程中 被中斷了，那么重新把中斷標志位設置上 
    9. 
   
  
  
  
  9.     selfInterrupt(); 
    10.

公平的重入鎖

默認情況下，重入鎖是不公平的。什么叫不公平呢。也就是說，如果有1,2,3,4 這四個線程，按順序，依次請求鎖。那等鎖可用的時候，誰會先拿到鎖呢?在非公平情況下，答案是隨機的。如下圖所示，可能線程3先拿到鎖。

 

如果你是一個公平主義者，強烈堅持先到先得的話，那么你就需要在構造重入鎖的時候，指定這是一個公平鎖：

  
 
 
 
    
   
  
  
  
  1. ReentrantLock fairLock = new ReentrantLock(true); 
    2.

這樣一來，每一個請求鎖的線程，都會乖乖的把自己放入請求隊列，而不是上來就進行爭搶。但一定要注意，公平鎖是有代價的。維持公平競爭是以犧牲系統(tǒng)性能為代價的。如果你愿意承擔這個損失，公平鎖至少提供了一種普世價值觀的實現吧!

那公平鎖和非公平鎖實現的核心區(qū)別在哪里呢?來看一下這段lock()的代碼：

  
 
 
 
    
   
  
  
  
  1. //非公平鎖  
    2. 
   
  
  
  
  2.  final void lock() { 
    3. 
   
  
  
  
  3.      //上來不管三七二十一，直接搶了再說 
    4. 
   
  
  
  
  4.      if (compareAndSetState(0, 1)) 
    5. 
   
  
  
  
  5.          setExclusiveOwnerThread(Thread.currentThread()); 
    6. 
   
  
  
  
  6.      else 
    7. 
   
  
  
  
  7.          //搶不到，就進隊列慢慢等著 
    8. 
   
  
  
  
  8.          acquire(1); 
    9. 
   
  
  
  
  9.  } 
    10. 
   
  
  
  
  10.  
    11. 
   
  
  
  
  11.  //公平鎖 
    12. 
   
  
  
  
  12.  final void lock() { 
    13. 
   
  
  
  
  13.      //直接進隊列等著 
    14. 
   
  
  
  
  14.      acquire(1); 
    15. 
   
  
  
  
  15.  } 
    16.

從上面的代碼中也不難看到，非公平鎖如果第一次爭搶失敗，后面的處理和公平鎖是一樣的，都是進入等待隊列慢慢等。

對于tryLock()也是非常類似的：

  
 
 
 
    
   
  
  
  
  1. //非公平鎖  
    2. 
   
  
  
  
  2. final boolean nonfairTryAcquire(int acquires) { 
    3. 
   
  
  
  
  3.      final Thread current = Thread.currentThread(); 
    4. 
   
  
  
  
  4.      int c = getState(); 
    5. 
   
  
  
  
  5.      if (c == 0) { 
    6. 
   
  
  
  
  6.          //上來不管三七二十一，直接搶了再說 
    7. 
   
  
  
  
  7.          if (compareAndSetState(0, acquires)) { 
    8. 
   
  
  
  
  8.              setExclusiveOwnerThread(current); 
    9. 
   
  
  
  
  9.              return true; 
    10. 
   
  
  
  
  10.          } 
    11. 
   
  
  
  
  11.      } 
    12. 
   
  
  
  
  12.      //如果就是當前線程占用了鎖，那么就更新一下state，表示重復占用鎖的次數 
    13. 
   
  
  
  
  13.      //這是“重入”的關鍵所在 
    14. 
   
  
  
  
  14.      else if (current == getExclusiveOwnerThread()) { 
    15. 
   
  
  
  
  15.          //我又來了哦~~~ 
    16. 
   
  
  
  
  16.          int nextc = c + acquires; 
    17. 
   
  
  
  
  17.          if (nextc < 0) // overflow 
    18. 
   
  
  
  
  18.              throw new Error("Maximum lock count exceeded"); 
    19. 
   
  
  
  
  19.          setState(nextc); 
    20. 
   
  
  
  
  20.          return true; 
    21. 
   
  
  
  
  21.      } 
    22. 
   
  
  
  
  22.      return false; 
    23. 
   
  
  
  
  23.  } 
    24. 
   
  
  
  
  24.  
    25. 
   
  
  
  
  25.  
    26. 
   
  
  
  
  26. //公平鎖 
    27. 
   
  
  
  
  27. protected final boolean tryAcquire(int acquires) { 
    28. 
   
  
  
  
  28.     final Thread current = Thread.currentThread(); 
    29. 
   
  
  
  
  29.     int c = getState(); 
    30. 
   
  
  
  
  30.     if (c == 0) { 
    31. 
   
  
  
  
  31.         //先看看有沒有別人在等，沒有人等我才會去搶，有人在我前面 ，我就不搶啦 
    32. 
   
  
  
  
  32.         if (!hasQueuedPredecessors() && 
    33. 
   
  
  
  
  33.             compareAndSetState(0, acquires)) { 
    34. 
   
  
  
  
  34.             setExclusiveOwnerThread(current); 
    35. 
   
  
  
  
  35.             return true; 
    36. 
   
  
  
  
  36.         } 
    37. 
   
  
  
  
  37.     } 
    38. 
   
  
  
  
  38.     else if (current == getExclusiveOwnerThread()) { 
    39. 
   
  
  
  
  39.         int nextc = c + acquires; 
    40. 
   
  
  
  
  40.         if (nextc < 0) 
    41. 
   
  
  
  
  41.             throw new Error("Maximum lock count exceeded"); 
    42. 
   
  
  
  
  42.         setState(nextc); 
    43. 
   
  
  
  
  43.         return true; 
    44. 
   
  
  
  
  44.     } 
    45. 
   
  
  
  
  45.     return false; 
    46. 
   
  
  
  
  46. } 
    47.

Condition

Condition可以理解為重入鎖的伴生對象。它提供了在重入鎖的基礎上，進行等待和通知的機制。可以使用 newCondition()方法生成一個Condition對象，如下所示。

  
 
 
 
    
   
  
  
  
  1. private final Lock lock = new ReentrantLock(); 
    2. 
   
  
  
  
  2. private final Condition condition = lock.newCondition(); 
    3.

那Condition對象怎么用呢。在JDK內部就有一個很好的例子。讓我們來看一下ArrayBlockingQueue吧。ArrayBlockingQueue是一個隊列，你可以把元素塞入隊列(enqueue)，也可以拿出來take()。但是有一個小小的條件，就是如果隊列是空的，那么take()就需要等待，一直等到有元素了，再返回。那這個功能，怎么實現呢?這就可以使用Condition對象了。

實現在ArrayBlockingQueue中，就維護一個Condition對象

  
 
 
 
    
   
  
  
  
  1. lock = new ReentrantLock(fair); 
    2. 
   
  
  
  
  2. notEmpty = lock.newCondition(); 
    3.

這個notEmpty 就是一個Condition對象。它用來通知其他線程，ArrayBlockingQueue是不是空著的。當我們需要拿出一個元素時:

  
 
 
 
    
   
  
  
  
  1. public E take() throws InterruptedException { 
    2. 
   
  
  
  
  2.     final ReentrantLock lock = this.lock; 
    3. 
   
  
  
  
  3.     lock.lockInterruptibly(); 
    4. 
   
  
  
  
  4.     try { 
    5. 
   
  
  
  
  5.         while (count == 0) 
    6. 
   
  
  
  
  6.             // 如果隊列長度為0，那么就在notEmpty condition上等待了，一直等到有元素進來為止 
    7. 
   
  
  
  
  7.             // 注意，await()方法，一定是要先獲得condition伴生的那個lock，才能用的哦 
    8. 
   
  
  
  
  8.             notEmpty.await(); 
    9. 
   
  
  
  
  9.         //一旦有人通知我隊列里有東西了，我就彈出一個返回 
    10. 
   
  
  
  
  10.         return dequeue(); 
    11. 
   
  
  
  
  11.     } finally { 
    12. 
   
  
  
  
  12.         lock.unlock(); 
    13. 
   
  
  
  
  13.     } 
    14. 
   
  
  
  
  14. } 
    15.

當有元素入隊時：

  
 
 
 
    
   
  
  
  
  1.  public boolean offer(E e) { 
    2. 
   
  
  
  
  2.     checkNotNull(e); 
    3. 
   
  
  
  
  3.     final ReentrantLock lock = this.lock; 
    4. 
   
  
  
  
  4.     //先拿到鎖，拿到鎖才能操作對應的Condition對象 
    5. 
   
  
  
  
  5.     lock.lock(); 
    6. 
   
  
  
  
  6.     try { 
    7. 
   
  
  
  
  7.         if (count == items.length) 
    8. 
   
  
  
  
  8.             return false; 
    9. 
   
  
  
  
  9.         else { 
    10. 
   
  
  
  
  10.             //入隊了， 在這個函數里，就會進行notEmpty的通知，通知相關線程，有數據準備好了 
    11. 
   
  
  
  
  11.             enqueue(e); 
    12. 
   
  
  
  
  12.             return true; 
    13. 
   
  
  
  
  13.         } 
    14. 
   
  
  
  
  14.     } finally { 
    15. 
   
  
  
  
  15.         //釋放鎖了，等著的那個線程，現在可以去彈出一個元素試試了 
    16. 
   
  
  
  
  16.         lock.unlock(); 
    17. 
   
  
  
  
  17.     } 
    18. 
   
  
  
  
  18. } 
    19. 
   
  
  
  
  19.  
    20. 
   
  
  
  
  20. private void enqueue(E x) { 
    21. 
   
  
  
  
  21.     final Object[] items = this.items; 
    22. 
   
  
  
  
  22.     items[putIndex] = x; 
    23. 
   
  
  
  
  23.     if (++putIndex == items.length) 
    24. 
   
  
  
  
  24.         putIndex = 0; 
    25. 
   
  
  
  
  25.     count++; 
    26. 
   
  
  
  
  26.     //元素已經放好了，通知那個等著拿東西的人吧 
    27. 
   
  
  
  
  27.     notEmpty.signal(); 
    28. 
   
  
  
  
  28. } 
    29.

因此，整個流程如圖所示：

 

重入鎖的使用示例

為了讓大家更好的理解重入鎖的使用方法?，F在我們使用重入鎖，實現一個簡單的計數器。這個計數器可以保證在多線程環(huán)境中，統(tǒng)計數據的精確性，請看下面示例代碼：

  
 
 
 
    
   
  
  
  
  1. public class Counter { 
    2. 
   
  
  
  
  2.     //重入鎖 
    3. 
   
  
  
  
  3.     private final Lock lock = new ReentrantLock(); 
    4. 
   
  
  
  
  4.     private int count; 
    5. 
   
  
  
  
  5.     public void incr() { 
    6. 
   
  
  
  
  6.         // 訪問count時，需要加鎖 
    7. 
   
  
  
  
  7.         lock.lock(); 
    8. 
   
  
  
  
  8.         try { 
    9. 
   
  
  
  
  9.             count++; 
    10. 
   
  
  
  
  10.         } finally { 
    11. 
   
  
  
  
  11.             lock.unlock(); 
    12. 
   
  
  
  
  12.         } 
    13. 
   
  
  
  
  13.     } 
    14. 
   
  
  
  
  14.      
    15. 
   
  
  
  
  15.     public int getCount() { 
    16. 
   
  
  
  
  16.         //讀取數據也需要加鎖，才能保證數據的可見性 
    17. 
   
  
  
  
  17.         lock.lock(); 
    18. 
   
  
  
  
  18.         try { 
    19. 
   
  
  
  
  19.             return count; 
    20. 
   
  
  
  
  20.         }finally { 
    21. 
   
  
  
  
  21.             lock.unlock(); 
    22. 
   
  
  
  
  22.         } 
    23. 
   
  
  
  
  23.     } 
    24. 
   
  
  
  
  24. } 
    25.

總結

可重入鎖算是多線程的入門級別知識點，所以我把他當做多線程系列的第一章節(jié)，對于重入鎖，我們需要特別知道幾點：

  1. 對于同一個線程，重入鎖允許你反復獲得通一把鎖，但是，申請和釋放鎖的次數必須一致。
  2. 默認情況下，重入鎖是非公平的，公平的重入鎖性能差于非公平鎖
  3. 重入鎖的內部實現是基于CAS操作的。
  4. 重入鎖的伴生對象Condition提供了await()和singal()的功能，可以用于線程間消息通信。

當前題目：我們聊一聊可重入鎖特別重要的話題
URL標題：http://www.5511xx.com/article/ccoidio.html