Java常用锁synchronized和ReentrantLock的区别_Java教程

Java常用锁synchronized和ReentrantLock的区别

2022-12-06 15:08Java中文社群 Java教程

这篇文章主要介绍了Java常用锁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 的代码段之后会自动释放锁，

如下图所示：

Java常用锁synchronized和ReentrantLock的区别

而 ReentrantLock 需要手动加锁和释放锁，如下图所示：

Java常用锁synchronized和ReentrantLock的区别

PS：在使用 ReentrantLock 时要特别小心，unlock 释放锁的操作一定要放在 finally 中，否者有可能会出现锁一直被占用，从而导致其他线程一直阻塞的问题。

区别3：锁类型不同

synchronized 属于非公平锁，而 ReentrantLock 既可以是公平锁也可以是非公平锁。

默认情况下 ReentrantLock 为非公平锁，这点查看源码可知：

Java常用锁synchronized和ReentrantLock的区别

使用 new ReentrantLock(true) 可以创建公平锁，查看源码可知：

Java常用锁synchronized和ReentrantLock的区别

区别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();
  }
}

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

Java常用锁synchronized和ReentrantLock的区别