在 Java 中，常用的鎖有兩種：synchronized（內(nèi)置鎖）和 ReentrantLock（可重入鎖），二者的功效都是相同得，但又有很多不同點(diǎn)，所以我們今天就來聊聊。

區(qū)別1：用法不同

synchronized 可用來修飾普通方法、靜態(tài)方法和代碼塊，而 ReentrantLock 只能用在代碼塊上。

synchronized 基礎(chǔ)使用

使用 synchronized 修飾代碼塊：

public void method(){
    // 加鎖代碼
    synchronized (this) {
        // ...
    }
}

ReentrantLock 基礎(chǔ)使用

ReentrantLock 在使用之前需要先創(chuàng)建 ReentrantLock 對(duì)象，然后使用 lock 方法進(jìn)行加鎖，使用完之后再調(diào)用 unlock 方法釋放鎖，具體使用如下：

public class LockExample {
    // 創(chuàng)建鎖對(duì)象
    private final ReentrantLock lock = new ReentrantLock();
    public void method(){
        // 加鎖操作
        lock.lock();
        try {
            // ...
        } finally {
            // 釋放鎖
            lock.unlock();
        }
    }
}

區(qū)別2：獲取鎖和釋放鎖方式不同

synchronized 會(huì)自動(dòng)加鎖和釋放鎖，當(dāng)進(jìn)入 synchronized 修飾的代碼塊之后會(huì)自動(dòng)加鎖，當(dāng)離開 synchronized 的代碼段之后會(huì)自動(dòng)釋放鎖，如下圖所示：

而 ReentrantLock 需要手動(dòng)加鎖和釋放鎖，如下圖所示：

PS：在使用 ReentrantLock 時(shí)要特別小心，unlock 釋放鎖的操作一定要放在 finally 中，否者有可能會(huì)出現(xiàn)鎖一直被占用，從而導(dǎo)致其他線程一直阻塞的問題。

區(qū)別3：鎖類型不同

synchronized 屬于非公平鎖，而 ReentrantLock 既可以是公平鎖也可以是非公平鎖。默認(rèn)情況下 ReentrantLock 為非公平鎖，這點(diǎn)查看源碼可知：

使用 new ReentrantLock(true) 可以創(chuàng)建公平鎖，查看源碼可知：

區(qū)別4：響應(yīng)中斷不同

ReentrantLock 可以使用 lockInterruptibly 獲取鎖并響應(yīng)中斷指令，而 synchronized 不能響應(yīng)中斷，也就是如果發(fā)生了死鎖，使用 synchronized 會(huì)一直等待下去，而使用 ReentrantLock 可以響應(yīng)中斷并釋放鎖，從而解決死鎖的問題，比如以下 ReentrantLock 響應(yīng)中斷的示例：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockInterrupt {
    static Lock lockA = new ReentrantLock();
    static Lock lockB = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        // 線程 1：先獲取 lockA 再獲取 lockB
        Thread t1 = new Thread(() -> {
            try {
                // 先獲取 LockA
                lockA.lockInterruptibly();
                // 休眠 10 毫秒
                TimeUnit.MILLISECONDS.sleep(100);
                // 獲取 LockB
                lockB.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("響應(yīng)中斷指令");
            } finally {
                // 釋放鎖
                lockA.unlock();
                lockB.unlock();
                System.out.println("線程 1 執(zhí)行完成。");
            }
        });
        // 線程 2：先獲取 lockB 再獲取 lockA
        Thread t2 = new Thread(() -> {
            try {
                // 先獲取 LockB
                lockB.lockInterruptibly();
                // 休眠 10 毫秒
                TimeUnit.MILLISECONDS.sleep(100);
                // 獲取 LockA
                lockA.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("響應(yīng)中斷指令");
            } finally {
                // 釋放鎖
                lockB.unlock();
                lockA.unlock();
                System.out.println("線程 2 執(zhí)行完成。");
            }
        });
        t1.start();
        t2.start();
        TimeUnit.SECONDS.sleep(1);
        // 線程1：執(zhí)行中斷
        t1.interrupt();
    }
}

以上程序的執(zhí)行結(jié)果如下所示：

區(qū)別5：底層實(shí)現(xiàn)不同

synchronized 是 JVM 層面通過監(jiān)視器（Monitor）實(shí)現(xiàn)的，而 ReentrantLock 是通過 AQS（AbstractQueuedSynchronizer）程序級(jí)別的 API 實(shí)現(xiàn)。synchronized 通過監(jiān)視器實(shí)現(xiàn)，可通過觀察編譯后的字節(jié)碼得出結(jié)論，如下圖所示：

其中 monitorenter 表示進(jìn)入監(jiān)視器，相當(dāng)于加鎖操作，而 monitorexit 表示退出監(jiān)視器，相當(dāng)于釋放鎖的操作。ReentrantLock 是通過 AQS 實(shí)現(xiàn)，可通過觀察 ReentrantLock 的源碼得出結(jié)論，核心實(shí)現(xiàn)源碼如下：

小結(jié)

synchronized 和 ReentrantLock 都是 Java 中提供的可重入鎖，二者的主要區(qū)別有以下 5 個(gè)：

1. 用法不同：synchronized 可以用來修飾普通方法、靜態(tài)方法和代碼塊，而 ReentrantLock 只能用于代碼塊。
2. 獲取鎖和釋放鎖的機(jī)制不同：synchronized 是自動(dòng)加鎖和釋放鎖的，而 ReentrantLock 需要手動(dòng)加鎖和釋放鎖。
3. 鎖類型不同：synchronized 是非公平鎖，而 ReentrantLock 默認(rèn)為非公平鎖，也可以手動(dòng)指定為公平鎖。
4. 響應(yīng)中斷不同：ReentrantLock 可以響應(yīng)中斷，解決死鎖的問題，而 synchronized 不能響應(yīng)中斷。
5. 底層實(shí)現(xiàn)不同：synchronized 是 JVM 層面通過監(jiān)視器實(shí)現(xiàn)的，而 ReentrantLock 是基于 AQS 實(shí)現(xiàn)的。