Java并发-显式锁篇【可重入锁+读写锁】

作者：汤圆

个人博客：javalover.cc

前言

在前面并发的开篇，我们介绍过内置锁synchronized；

这节我们再介绍下显式锁Lock

显式锁包括：可重入锁ReentrantLock、读写锁ReadWriteLock

关系如下所示：

简介

显式锁和内置锁最大的区别就是：显式锁需手动获取锁和释放锁，而内置锁不需要

关于显式锁，本节会分别介绍可它的实现类 - 可重入锁，以及它的相关类 - 读写锁

• 可重入锁，实现了显式锁，意思就是可重入的显式锁（内置锁也是可重入的）
• 读写锁，将显式锁分为读写分离，即读读可并行，多个线程同时读不会阻塞（读写，写写还是串行）

下面让我们开始吧

文章如果有问题，欢迎大家批评指正，在此谢过啦

目录

1. 可重入锁 ReentrantLock
2. 读写锁 ReadWriteLock
3. 区别

正文

1.可重入锁 ReentrantLock

我们先来看下它的几个方法：

• public ReentrantLock();构造函数，默认构造非公平的锁（可插队，如果某个线程获取锁时，刚好锁被释放，那么这个线程就会立马获得锁，而不管队列里的线程是否在等待）
• public void lock()：获取锁，以阻塞的方式（如果其他线程持有锁，则阻塞当前线程，直到锁被释放）；
• public void lockInterruptibly() throws InterruptedException：获取锁，以可被中断的方式（如果当前线程被中断，则抛出中断异常）；
• public boolean tryLock(): 尝试获取锁，如果锁被其他线程持有，则立马返回false
• public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException:尝试获取锁，并设置一个超时时间（如果超过这个时间，还没获取到锁，则返回false）
• public void unlock(): 释放锁 首先我们先看下它的构造方法，内部实现如下： public ReentrantLock() { sync = new NonfairSync(); } 可以看到，这里创建了一个非公平锁 公平锁：如果获取锁时，被其他线程持有，则将当前线程放入等待队列 非公平锁：如果获取锁时，刚好锁被释放，那么这个线程就会立马获得锁，而不管队列里的线程是否在等待 非公平锁的好处就是，可以减少线程的挂起和唤醒开销 如果某个线程的执行任务所需时间很短，甚至比唤醒队列中的线程所消耗的时间还短，那么非公平锁的优势就很明显 我们可以假设这样一个情景：
  • 线程A的任务执行耗时为10ms
  • 而唤醒队列中的线程B到执行真正去执行线程B的任务耗时为20ms
  • 那么当线程A去获取锁时，刚好锁又被释放，此时线程A抢先获得锁，并执行任务，然后释放锁
  • 当线程A释放锁之后，队列中当线程B才被唤醒正要去获取锁，那么线程B被唤醒的这段时间CPU就没有被浪费，从而提高了程序的性能

  这也是为啥默认是非公平锁的原因（一般情况下，非公平锁的性能高于公平锁） 那什么时候应该用公平锁呢？

  • 持有锁的时间较长，即线程的任务执行耗时较长
  • 请求锁的时间间隔较长

  因为这种情况下，如果线程插队获取到锁，结果任务还半天执行不完，那么队列中被唤醒的线程醒来发现锁还是被占有的，就会被再次放到队列中（此时并不会提高性能，还有可能降低） 接下来我们看下关键的部分：获取锁 获取锁有多个方法，我们用代码来看下他们之间的区别

  1. 先来看下lock()方法，示例代码如下：

  public class ReentrantLockDemo { ​ private Lock lock = new ReentrantLock(); ​ private int i = 0; ​ public void add(){ lock.lock(); try { i++; }finally { System.out.println(i); lock.unlock(); } } ​ public static void main(String[] args) throws InterruptedException { ReentrantLockDemo demo = new ReentrantLockDemo(); ExecutorService service = Executors.newFixedThreadPool(5); for (int i = 0; i < 100; i++) { service.submit(()->{ demo.add(); }); } } } 依次输出1～100，这是因为lock()获取锁时，会以阻塞的方式来获取

  1. 接下来看下 tryLock()方法，代码如下：

  public class ReentrantLockDemo { ​ private Lock lock = new ReentrantLock(); ​ private int i = 0; ​ public void tryAdd(){ if(lock.tryLock()){ try { i++; }finally { System.out.println(i); lock.unlock(); } } } ​ public static void main(String[] args) throws InterruptedException { ReentrantLockDemo demo = new ReentrantLockDemo(); ExecutorService service = Executors.newFixedThreadPool(5); for (int i = 0; i < 100; i++) { service.submit(()->{ demo.tryAdd(); }); } } } ​ 运行发现，输出永远都少于100，是因为tryLock()如果获取锁失败，会立马返回false，而不是阻塞等待

  1. 最后我们来看下lockInterruptibly()方法，它也是阻塞获取锁，只是比lock()多了个中断异常，即获取锁时，如果线程被中断，则抛出中断异常

  public class ReentrantLockDemo { ​ private Lock lock = new ReentrantLock(); ​ private int i = 0; ​ public void interruptAdd(){ try { lock.lockInterruptibly(); i++; } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(i); lock.unlock(); } } ​ public static void main(String[] args) throws InterruptedException { ReentrantLockDemo demo = new ReentrantLockDemo(); ExecutorService service = Executors.newFixedThreadPool(5); for (int i = 0; i < 100; i++) { // 第10次，立马关闭线程池，停止所有的线程（包括正在执行的和正在等待的） if (10 == i){ service.shutdownNow(); } service.submit(()->{ demo.interruptAdd(); }); } ​ } } ​ 多运行几次，有可能输出如下： 1 2 3 4 5 6 6 6 6 6 java.lang.InterruptedException at ...... 这就是因为前面几个都是正常获取到锁并执行了i++,但是后面的几个线程因为被突然停止，所以抛出中断异常

  1. 最后就是释放锁, unlock()

  这个就很简单了，上面的代码都有涉及到这个释放锁 不过细心的朋友可能发现了，上面的unlock()都是在finally块中编写的 这是因为在获取锁并执行任务时，有可能抛出异常，此时如果不把unlock()放到finally块中，那么锁不被释放，这在后期是一个很大的隐患（其他线程无法再次获取到这个锁，如果是lock()形式的获取锁，则线程会一直阻塞） 这也是显式锁无法完全替代内置锁的一个原因，有危险 2. 读写锁 ReadWriteLock 读写锁内部就两个方法，分别返回读锁和写锁 读锁属于共享锁，而写锁属于独占锁（前面介绍的可重入锁和内置锁也是独占锁） 读锁允许多个线程同时获取一个锁，因为读不会修改数据，它很适合读多写少的场合 下面我们用代码来看下 先看下读锁，代码如下： public class ReadWriteLockDemo { ​ private int i = 0; private Lock readLock; private Lock writeLock; ​ ​ public ReadWriteLockDemo() { ReadWriteLock lock = new ReentrantReadWriteLock(); this.readLock = lock.readLock(); this.writeLock = lock.writeLock(); } ​ public void readFun(){ readLock.lock(); System.out.println("=== 获取到 读锁 ==="); try { System.out.println(i); }finally { readLock.unlock(); System.out.println("=== 释放了 读锁 ==="); } } ​ public static void main(String[] args) throws InterruptedException { ReadWriteLockDemo demo = new ReadWriteLockDemo(); ExecutorService executors = Executors.newFixedThreadPool(2); for (int i = 0; i < 10; i++) { executors.submit(()->{ demo.readFun(); }); } } } 多次运行，有可能输出下面的结果： === 获取到 读锁 === 0 === 获取到 读锁 === 可以看到，两个线程都获取到了读锁，这就是读锁的优势，多个线程同时读 下面看下写锁，代码如下：（这里用到了ReentrantReadWriteLock类，表示可重入的读写锁） public class ReadWriteLockDemo { ​ private int i = 0; private Lock readLock; private Lock writeLock; ​ public ReadWriteLockDemo() { ReadWriteLock lock = new ReentrantReadWriteLock(); this.readLock = lock.readLock(); this.writeLock = lock.writeLock(); } ​ public void writeFun(){ writeLock.lock(); System.out.println("=== 获取到 写锁 ==="); try { i++; System.out.println(i); }finally { writeLock.unlock(); System.out.println("=== 释放了 写锁 ==="); } } ​ public static void main(String[] args) throws InterruptedException { ReadWriteLockDemo demo = new ReadWriteLockDemo(); ExecutorService executors = Executors.newFixedThreadPool(2); for (int i = 0; i < 10; i++) { executors.submit(()->{ demo.writeFun(); }); } } ​ } ​ 输出如下：可以看到，写锁类似上面的重入锁的lock()方法，阻塞获取写锁 === 获取到 写锁 === 1 === 释放了 写锁 === === 获取到 写锁 === 2 === 释放了 写锁 === === 获取到 写锁 === 3 === 释放了 写锁 === === 获取到 写锁 === 4 === 释放了 写锁 === === 获取到 写锁 === 5 === 释放了 写锁 === === 获取到 写锁 === 6 === 释放了 写锁 === === 获取到 写锁 === 7 === 释放了 写锁 === === 获取到 写锁 === 8 === 释放了 写锁 === === 获取到 写锁 === 9 === 释放了 写锁 === === 获取到 写锁 === 10 === 释放了 写锁 === 关于读写锁，需要注意的一点是，读锁和写锁必须基于同一个ReadWriteLock类才有意义 如果读锁和写锁分别是从两个ReadWrite Lock类中获取的，那么读锁和写锁就是完全无关的两个锁，也就不会起到锁的作用（阻止其他线程访问） 这就类似synchronized(a)和synchronized(b)，分别锁了两个对象，此时单个线程是可以同时访问这两个锁的 3. 区别 我们用表格来展示吧，细节如下： 锁的特点内置锁可重入锁读写锁灵活性低高高公平性不确定非公平（默认）+公平非公平（默认）+公平定时性无可定时可定时中断性无可中断可中断互斥性互斥互斥读读共享，其他都互斥建议优先选择内置锁，只有在内置锁满足不了需求时，再采用显式锁（比如可定时、可中断、公平性） 如果是读多写少的场景（比如配置数据），推荐用读写锁 总结

  1. 可重入锁 ReentrantLock：需显式获取锁和释放锁，切记要在finally块中释放锁
  2. 读写锁 ReadWriteLock：基于显式锁（显式锁有的它都有），多了读写分离，实现了读读共享（多个线程同时读），其他都不共享（读写，写写）
  3. 区别：内置锁不支持手动获取/释放锁、公平性选择、定时、中断，显式锁支持

  建议使用锁时，优先考虑内置锁 因为现在内置锁的性能跟显式锁差别不大 而且显式锁因为需要手动释放锁（需在finally块中释放），所以会有忘记释放的风险 如果是读多写少的场合，则推荐用读写锁（成对的读锁和写锁需从同一个读写锁类获取） 参考内容：

  • 《Java并发编程实战》
  • 《实战Java高并发》

  后记 最后，祝愿所有人都心想事成，阖家欢乐