JUC并發編程中的鎖有哪些

這篇文章主要講解了“JUC并發編程中的鎖有哪些”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“JUC并發編程中的鎖有哪些”吧！

當多個線程訪問一個對象時，如果不用考慮這些線程在運行環境下的調度和交替執行，也不需要進行額外的同步，或者在調用方進行任何其他的協調操作，調用這個對象的行為都可以獲得正確的結果，那么這個對象就是線程安全的。但是現實并不是這樣子的，所以JVM實現了鎖機制，今天就叭叭叭JAVA中各種各樣的鎖。

1、自旋鎖和自適應鎖

自旋鎖：在多線程競爭的狀態下共享數據的鎖定狀態只會持續很短的一段時間，為了這段時間去掛起和恢復阻塞線程并不值得，而是讓沒有獲取到鎖的線程自旋（自旋并不會放棄CPU的分片時間）等待當前線程釋放鎖，如果自旋超過了限定的次數仍然沒有成功獲取到鎖，就應該使用傳統的方式去掛起線程了，在JDK定義中，自旋鎖默認的自旋次數為10次，用戶可以使用參數-XX:PreBlockSpin來更改（jdk1.6之后默認開啟自旋鎖）。

自適應鎖：為了解決某些特殊情況，如果自旋剛結束，線程就釋放了鎖，那么是不是有點不劃算。自適應自旋鎖是jdk1.6引入，規定自旋的時間不再固定了，而是由前一次在同一個鎖上的自旋 時間及鎖的擁有者的狀態來決定的。如果在同一個鎖對象上，自旋等待剛剛成功獲取過鎖，并且持有鎖的線程正在運行中，那么JVM會認為該線程自旋獲取到鎖的可能性很大，會自動增加等待時間。反之就認為不容易獲取到鎖，而放棄自旋這種方式。

鎖消除：鎖消除時指虛擬機即時編譯器在運行時，對一些代碼上要求同步，但是被檢測到不可能存在共享數據競爭的鎖進行消除。意思就是：在一段代碼中，堆上的所有數據都不會逃逸出去而被其他線程訪問到那就可以把他們當作棧上的數據對待，認為他們是線程私有的，不用再加鎖。

鎖粗化：

  public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("a");
        buffer.append("b");
        buffer.append("c");
        System.out.println("拼接之后的結果是:>>>>>>>>>>>"+buffer);
    }

  @Override
    @IntrinsicCandidate
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

StringBuffer 在拼接字符串時是同步的。但是在一系列的操作中都對同一個對象（StringBuffer ）反復加鎖和解鎖，頻繁的進行加鎖解鎖操作會導致不必要的性能損耗，JVM會將加鎖同步的范圍擴展到整個操作的外部，只加一次鎖。

2、輕量級鎖和重量級鎖

這種鎖實現的背后基于這樣一種假設，即在真實的情況下我們程序中的大部分同步代碼一般都處于無鎖競爭狀態(即單線程執行環境)，在無鎖競爭的情況下完全可以避免調用操作系統層面的重量級互斥鎖， 取而代之的是在monitorenter和monitorexit中只需要依靠一條CAS原子指令就可以完成鎖的獲取及釋放。輕量級鎖是相對于重量級鎖而言的。

輕量級鎖加鎖過程

在HotSpot虛擬機的對象頭分為兩部分，一部分用于存儲對象自身的運行時數據，如Hashcode、GC分代年齡、標志位等，這部分長度在32位和64位的虛擬機中分別是32bit和64bit，稱為Mark Word。另一部分用于存儲指向方法區對象類型數據的指針，如果是數組對象的話，還會有一個額外的部分用于存儲數組長度。

對象頭信息是與對象自身定義的數據無關的額外存儲成本，Mark Word 被設計成一個非固定的數據結構以便在極小的空間內存儲盡量多的信息。mark word中有兩個bit存儲鎖標記位。

HotSpot虛擬機對象頭Mark Word

在代碼進入同步代碼塊時，如果此對象沒有被鎖定（標記位為01狀態），虛擬機首先在當前線程的棧幀建立一個名為鎖記錄（Lock Record）的空間，用于存儲鎖對象目前Mark Word的拷貝，然后虛擬機使用CAS操作嘗試將對象的Mark Word 更新為指向Lock Record的指針，如果操作成功了，那么這個線程就有了這個對象的鎖，并且將Mark Word 的標記位更改為00，表示這個對象處于輕量級鎖定狀態。如果更新失敗了虛擬機會首先檢查是否是當前線程擁有了這個對象的鎖，如果是就進入同步代碼，如果不是，那就說明鎖被其他線程占用了。如果有兩個以上的線程爭奪同一個鎖，那輕量級鎖就不再有效，要膨脹為重量級鎖，鎖標記位變為10，后面等待的線程就要進入阻塞狀態。

輕量級鎖解鎖過程

解鎖過程同樣使用CAS操作來進行，使用CAS操作將Mark Word 指向Lock Record 指針釋放，如果操作成功，那么整個同步過程就完成了，如果釋放失敗，說明有其他線程嘗試獲取該鎖，那就在釋放鎖的同時，喚醒被掛起的線程。

3、偏向鎖

JVM 參數 -XX：-UseBiasedLocking 禁用偏向鎖；-XX：+UseBiasedLocking 啟用偏向鎖。

        啟用了偏向鎖才會執行偏向鎖的操作。當鎖對象第一次被線程獲取時，虛擬機會把對象頭中的標記位設置為01，偏向模式。同時使用CAS操作獲取到當前線程的線程ID存儲到Mark Word 中，如果操作成功，那么持有偏向鎖的線程以后每次進入這個鎖相關的同步塊時，都不需要任何操作，直接進入。如果有多個線程去嘗試獲取這個鎖時，偏向鎖就宣告無效，然后會撤銷偏向或者恢復到未鎖定。然后再膨脹為重量級鎖，標記位狀態變為10。

4、可重入鎖和不可重入鎖

可重入鎖就是一個線程獲取到鎖之后，在另一個代碼塊還需要該鎖，那么不需要重新獲取而可以直接使用該鎖。大多數的鎖都是可重入鎖。但是CAS自旋鎖不可重入。

package com.xiaojie.juc.thread.lock;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @author xiaojie
 * @version 1.0
 * @description: 測試鎖的重入性
 * @date 2021/12/30 22:09
 */
public class Test01 {
    public synchronized void a() {
        System.out.println(Thread.currentThread().getName() + "運行a方法");
        b();
    }
    private synchronized void b() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "運行b方法");
    }
    public static void main(String[] args) {
        Test01 test01 = new Test01();
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i=0;i<10;i++){
            executorService.execute(() -> test01.a());
        }
    }
}

5、悲觀鎖和樂觀鎖

悲觀鎖總是悲觀的，總是認為會發生安全問題，所以每次操作都會加鎖。比如獨占鎖、傳統數據庫中的行鎖、表鎖、讀鎖、寫鎖等。悲觀鎖存在以下幾個缺點：

• 在多線程競爭下，加鎖、釋放鎖會導致比較多的上下文切換和調度延遲，引起性能問題。

• 一個線程占有鎖后，其他線程就得阻塞等待。

• 如果優先級高的線程等待一個優先級低的線程，會導致線程優先級導致，可能引發性能風險。

樂觀鎖總是樂觀的，總是認為不會發生安全問題。在數據庫中可以使用版本號實現樂觀鎖，JAVA中的CAS和一些原子類都是樂觀鎖的思想。

6、公平鎖和非公平鎖

公平鎖：是指多個線程在等待同一個鎖時，必須按照申請鎖的時間順序來依次獲得鎖。

非公平鎖：非公平鎖不需要按照申請鎖的時間順序來獲取鎖，而是誰能獲取到CPU的時間片誰就先執行。非公平鎖的優點是吞吐量比公平鎖大，缺點是有可能導致線程優先級反轉或者造成過線程饑餓現象（就是有的線程玩命的一直在執行任務，有的線程至死沒有執行一個任務）。

synchronized中的鎖是非公平鎖，ReentrantLock默認也是非公平鎖，但是可以通過構造函數設置為公平鎖。

7、共享鎖和獨占鎖

共享鎖就是同一時刻允許多個線程持有的鎖。例如Semaphore（信號量）、ReentrantReadWriteLock的讀鎖、CountDownLatch倒數閂等。

獨占鎖也叫排它鎖、互斥鎖、獨占鎖是指鎖在同一時刻只能被一個線程所持有。例如synchronized內置鎖和ReentrantLock顯示鎖，ReentrantReadWriteLock的寫鎖都是獨占鎖。

package com.xiaojie.juc.thread.lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * @description: 讀寫鎖驗證共享鎖和獨占鎖
 * @author xiaojie
 * @date 2021/12/30 23:28
 * @version 1.0
 */
public class ReadAndWrite {
    static class ReadThred extends Thread {
        private ReentrantReadWriteLock lock;
        private String name;
        public ReadThred(String name, ReentrantReadWriteLock lock) {
            super(name);
            this.lock = lock;
        }
        @Override
        public void run() {
            try {
                lock.readLock().lock();
                System.out.println(Thread.currentThread().getName() + "這是共享鎖。。。。。。");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.readLock().unlock();
                System.out.println(Thread.currentThread().getName() + "釋放鎖成功。。。。。。");
            }
        }
    }
    static class WriteThred extends Thread {
        private ReentrantReadWriteLock lock;
        private String name;
        public WriteThred(String name, ReentrantReadWriteLock lock) {
            super(name);
            this.lock = lock;
        }
        @Override
        public void run() {
            try {
                lock.writeLock().lock();
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + "這是獨占鎖。。。。。。。。");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.writeLock().unlock();
                System.out.println(Thread.currentThread().getName() + "釋放鎖。。。。。。。");
            }
        }
    }
    public static void main(String[] args) {
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        ReadThred readThred1 = new ReadThred("read-thread-1", reentrantReadWriteLock);
        ReadThred readThred2 = new ReadThred("read-thread-1", reentrantReadWriteLock);
        WriteThred writeThred1 = new WriteThred("write-thread-1", reentrantReadWriteLock);
        WriteThred writeThred2 = new WriteThred("write-thread-2", reentrantReadWriteLock);
        readThred1.start();
        readThred2.start();
        writeThred1.start();
        writeThred2.start();
    }
}

8、可中斷鎖和不可中斷鎖

可中斷鎖只在搶占鎖的過程中可以被中斷的鎖如ReentrantLock。

不可中斷鎖是不可中斷的鎖如java內置鎖synchronized。

總結：

感謝各位的閱讀，以上就是“JUC并發編程中的鎖有哪些”的內容了，經過本文的學習后，相信大家對JUC并發編程中的鎖有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！