面試必問：synchronized和ReentrantLock有什么區別？

作者：磊哥 2023-02-01 07:15:16

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

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

區別1：用法不同

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

synchronized 基礎使用

使用 synchronized 修飾代碼塊：

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

ReentrantLock 基礎使用

ReentrantLock 在使用之前需要先創建 ReentrantLock 對象，然后使用 lock 方法進行加鎖，使用完之后再調用 unlock 方法釋放鎖，具體使用如下：

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

區別2：獲取鎖和釋放鎖方式不同

synchronized 會自動加鎖和釋放鎖，當進入 synchronized 修飾的代碼塊之后會自動加鎖，當離開 synchronized 的代碼段之后會自動釋放鎖，如下圖所示：

而 ReentrantLock 需要手動加鎖和釋放鎖，如下圖所示：

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

區別3：鎖類型不同

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

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

區別4：響應中斷不同

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

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("響應中斷指令");
            } finally {
                // 釋放鎖
                lockA.unlock();
                lockB.unlock();
                System.out.println("線程 1 執行完成。");
            }
        });
        // 線程 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("響應中斷指令");
            } finally {
                // 釋放鎖
                lockB.unlock();
                lockA.unlock();
                System.out.println("線程 2 執行完成。");
            }
        });
        t1.start();
        t2.start();
        TimeUnit.SECONDS.sleep(1);
        // 線程1：執行中斷
        t1.interrupt();
    }
}