Java中各種鎖的原理決議

下圖匯總了各種鎖和其適用條件

1. 樂觀鎖 VS 悲觀鎖

        對于同一個資料的并發操作，悲觀鎖認為自己在使用資料的時候一定有別的執行緒來修改資料，因此在獲取資料的時候會先加鎖，確保資料不會被別的執行緒修改，

       Java中，synchronized關鍵字和Lock的實作類都是悲觀鎖，

       而樂觀鎖認為自己在使用資料時不會有別的執行緒修改資料，所以不會添加鎖!

樂觀鎖和悲觀鎖的呼叫方式示例：

/ ------------------------- 悲觀鎖的呼叫方式 -------------------------
// synchronized
public synchronized void testMethod() {
    // 操作同步資源
}
// ReentrantLock
private ReentrantLock lock = new ReentrantLock(); // 需要保證多個執行緒使用的是同一個鎖
public void modifyPublicResources() {
    lock.lock();
    // 操作同步資源
    lock.unlock();
}

// ------------------------- 樂觀鎖的呼叫方式 -------------------------
private AtomicInteger atomicInteger = new AtomicInteger();  // 需要保證多個執行緒使用的是同一個AtomicInteger
atomicInteger.incrementAndGet(); //執行自增1

2. 自旋鎖 VS 適應性自旋鎖

       在許多場景中，同步資源的鎖定時間很短，為了這一小段時間去切換執行緒，執行緒掛起和恢復現場的花費可能會讓系統得不償失，如果物理機器有多個處理器，能夠讓兩個或以上的執行緒同時并行執行，我們就可以讓后面那個請求鎖的執行緒不放棄CPU的執行時間，看看持有鎖的執行緒是否很快就會釋放鎖，

       而為了讓當前執行緒“稍等一下”，我們需讓當前執行緒進行自旋，如果在自旋完成后前面鎖定同步資源的執行緒已經釋放了鎖，那么當前執行緒就可以不必阻塞而是直接獲取同步資源，從而避免切換執行緒的開銷，這就是自旋鎖，

      自旋鎖本身是有缺點的，它不能代替阻塞，自旋等待雖然避免了執行緒切換的開銷，但它要占用處理器時間，如果鎖被占用的時間很短，自旋等待的效果就會非常好，反之，如果鎖被占用的時間很長，那么自旋的執行緒只會白浪費處理器資源，所以，自旋等待的時間必須要有一定的限度，如果自旋超過了限定次數（默認是10次，可以使用-XX:PreBlockSpin來更改）沒有成功獲得鎖，就應當掛起執行緒，

      自旋鎖在JDK1.4.2中引入，使用-XX:+UseSpinning來開啟，JDK 6中變為默認開啟，并且引入了自適應的自旋鎖（適應性自旋鎖），

      自適應意味著自旋的時間（次數）不再固定，而是由前一次在同一個鎖上的自旋時間及鎖的擁有者的狀態來決定，如果在同一個鎖物件上，自旋等待剛剛成功獲得過鎖，并且持有鎖的執行緒正在運行中，那么虛擬機就會認為這次自旋也是很有可能再次成功，進而它將允許自旋等待持續相對更長的時間，如果對于某個鎖，自旋很少成功獲得過，那在以后嘗試獲取這個鎖時將可能省略掉自旋程序，直接阻塞執行緒，避免浪費處理器資源，

在自旋鎖中 另有三種常見的鎖形式:TicketLock、CLHlock和MCSlock

3. 無鎖 VS 偏向鎖 VS 輕量級鎖 VS 重量級鎖

這四種鎖是指鎖的狀態，專門針對synchronized的，在介紹這四種鎖狀態之前還需要介紹一些額外的知識，

首先為什么Synchronized能實作執行緒同步？

在回答這個問題之前我們需要了解兩個重要的概念：“Java物件頭”、“Monitor”，

Java物件頭

synchronized是悲觀鎖，在操作同步資源之前需要給同步資源先加鎖，這把鎖就是存在Java物件頭里的，而Java物件頭又是什么呢？

我們以Hotspot虛擬機為例，Hotspot的物件頭主要包括兩部分資料：Mark Word（標記欄位）、Klass Pointer（型別指標），

Mark Word：默認存盤物件的HashCode，分代年齡和鎖標志位資訊，這些資訊都是與物件自身定義無關的資料，所以Mark Word被設計成一個非固定的資料結構以便在極小的空間記憶體存盤盡量多的資料，它會根據物件的狀態復用自己的存盤空間，也就是說在運行期間Mark Word里存盤的資料會隨著鎖標志位的變化而變化，

Klass Point：物件指向它的類元資料的指標，虛擬機通過這個指標來確定這個物件是哪個類的實體，

Monitor

Monitor可以理解為一個同步工具或一種同步機制，通常被描述為一個物件，每一個Java物件就有一把看不見的鎖，稱為內部鎖或者Monitor鎖，

Monitor是執行緒私有的資料結構，每一個執行緒都有一個可用monitor record串列，同時還有一個全域的可用串列，每一個被鎖住的物件都會和一個monitor關聯，同時monitor中有一個Owner欄位存放擁有該鎖的執行緒的唯一標識，表示該鎖被這個執行緒占用，

現在話題回到synchronized，synchronized通過Monitor來實作執行緒同步，Monitor是依賴于底層的作業系統的Mutex Lock（互斥鎖）來實作的執行緒同步，

如同我們在自旋鎖中提到的“阻塞或喚醒一個Java執行緒需要作業系統切換CPU狀態來完成，這種狀態轉換需要耗費處理器時間，如果同步代碼塊中的內容過于簡單，狀態轉換消耗的時間有可能比用戶代碼執行的時間還要長”，這種方式就是synchronized最初實作同步的方式，這就是JDK 6之前synchronized效率低的原因，這種依賴于作業系統Mutex Lock所實作的鎖我們稱之為“重量級鎖”，JDK 6中為了減少獲得鎖和釋放鎖帶來的性能消耗，引入了“偏向鎖”和“輕量級鎖”，

所以目前鎖一共有4種狀態，級別從低到高依次是：無鎖、偏向鎖、輕量級鎖和重量級鎖，鎖狀態只能升級不能降級，

通過上面的介紹，我們對synchronized的加鎖機制以及相關知識有了一個了解，那么下面我們給出四種鎖狀態對應的的Mark Word內容，然后再分別講解四種鎖狀態的思路以及特點：

4. 公平鎖 VS 非公平鎖

公平鎖是指多個執行緒按照申請鎖的順序來獲取鎖，執行緒直接進入佇列中排隊，佇列中的第一個執行緒才能獲得鎖，公平鎖的優點是等待鎖的執行緒不會餓死，缺點是整體吞吐效率相對非公平鎖要低，等待佇列中除第一個執行緒以外的所有執行緒都會阻塞，CPU喚醒阻塞執行緒的開銷比非公平鎖大，

非公平鎖是多個執行緒加鎖時直接嘗試獲取鎖，獲取不到才會到等待佇列的隊尾等待，但如果此時鎖剛好可用，那么這個執行緒可以無需阻塞直接獲取到鎖，所以非公平鎖有可能出現后申請鎖的執行緒先獲取鎖的場景，非公平鎖的優點是可以減少喚起執行緒的開銷，整體的吞吐效率高，因為執行緒有幾率不阻塞直接獲得鎖，CPU不必喚醒所有執行緒，缺點是處于等待佇列中的執行緒可能會餓死，或者等很久才會獲得鎖，

5. 可重入鎖 VS 非可重入鎖

 可重入鎖又名遞回鎖，是指在同一個執行緒在外層方法獲取鎖的時候，再進入該執行緒的內層方法會自動獲取鎖（前提鎖物件得是同一個物件或者class），不會因為之前已經獲取過還沒釋放而阻塞，Java中ReentrantLock和synchronized都是可重入鎖，可重入鎖的一個優點是可一定程度避免死鎖，下面用示例代碼來進行分析：

public class Widget {
    public synchronized void doSomething() {
        System.out.println("方法1執行...");
        doOthers();
    }

    public synchronized void doOthers() {
        System.out.println("方法2執行...");
    }
}

在上面的代碼中，類中的兩個方法都是被內置鎖synchronized修飾的，doSomething()方法中呼叫doOthers()方法，因為內置鎖是可重入的，所以同一個執行緒在呼叫doOthers()時可以直接獲得當前物件的鎖，進入doOthers()進行操作，

如果是一個不可重入鎖，那么當前執行緒在呼叫doOthers()之前需要將執行doSomething()時獲取當前物件的鎖釋放掉，實際上該物件鎖已被當前執行緒所持有，且無法釋放，所以此時會出現死鎖，

6. 獨享鎖(排它鎖) VS 共享鎖

       獨享鎖也叫排他鎖，是指該鎖一次只能被一個執行緒所持有，如果執行緒T對資料A加上排它鎖后，則其他執行緒不能再對A加任何型別的鎖，獲得排它鎖的執行緒即能讀資料又能修改資料，JDK中的synchronized和JUC中Lock的實作類就是互斥鎖，

       共享鎖是指該鎖可被多個執行緒所持有，如果執行緒T對資料A加上共享鎖后，則其他執行緒只能對A再加共享鎖，不能加排它鎖，獲得共享鎖的執行緒只能讀資料，不能修改資料，

       獨享鎖與共享鎖也是通過AQS來實作的，通過實作不同的方法，來實作獨享或者共享，

下圖為ReentrantReadWriteLock的部分原始碼：

 我們看到ReentrantReadWriteLock有兩把鎖：ReadLock和WriteLock，由詞知意，一個讀鎖一個寫鎖，合稱“讀寫鎖”，再進一步觀察可以發現ReadLock和WriteLock是靠內部類Sync實作的鎖，Sync是AQS的一個子類，這種結構在CountDownLatch、ReentrantLock、Semaphore里面也都存在，

在ReentrantReadWriteLock里面，讀鎖和寫鎖的鎖主體都是Sync，但讀鎖和寫鎖的加鎖方式不一樣，讀鎖是共享鎖，寫鎖是獨享鎖，讀鎖的共享鎖可保證并發讀非常高效，而讀寫、寫讀、寫寫的程序互斥，因為讀鎖和寫鎖是分離的，所以ReentrantReadWriteLock的并發性相比一般的互斥鎖有了很大提升，

參考文章：https://tech.meituan.com/2018/11/15/java-lock.html

標籤：Java

上一篇：Spring Security 實戰干貨：OAuth2登錄獲取Token的核心邏輯

下一篇：java的byte和C#的byte的不同之處