关于java:面试突击42synchronized和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();}
}

以上程序的执行后果如下所示：

区别 5：底层实现不同

synchronized 是 JVM 层面通过监视器（Monitor）实现的，而 ReentrantLock 是通过 AQS（AbstractQueuedSynchronizer）程序级别的 API 实现。
synchronized 通过监视器实现，可通过观察编译后的字节码得出结论，如下图所示：

其中 monitorenter 示意进入监视器，相当于加锁操作，而 monitorexit 示意退出监视器，相当于开释锁的操作。
ReentrantLock 是通过 AQS 实现，可通过观察 ReentrantLock 的源码得出结论，外围实现源码如下：

小结

synchronized 和 ReentrantLock 都是 Java 中提供的可重入锁，二者的次要区别有以下 5 个：

1. 用法不同：synchronized 能够用来润饰一般办法、静态方法和代码块，而 ReentrantLock 只能用于代码块。
2. 获取锁和开释锁的机制不同：synchronized 是主动加锁和开释锁的，而 ReentrantLock 须要手动加锁和开释锁。
3. 锁类型不同：synchronized 是非偏心锁，而 ReentrantLock 默认为非偏心锁，也能够手动指定为偏心锁。
4. 响应中断不同：ReentrantLock 能够响应中断，解决死锁的问题，而 synchronized 不能响应中断。
5. 底层实现不同：synchronized 是 JVM 层面通过监视器实现的，而 ReentrantLock 是基于 AQS 实现的。

是非审之于己，毁誉听之于人，得失安之于数。

公众号：Java 面试真题解析

面试合集：https://gitee.com/mydb/interview