Java中的读写锁ReentrantReadWriteLock详解，存在一个小缺陷

写在开头

最近是和java.util.concurrent.locks包下的同步类干上了，素有 并发根基 之称的concurrent包中全是精品，今天我们继续哈，今天学习的主题要由一个大厂常问的Java面试题开始：

小伙子，来说一说Java中的读写锁，你都用过哪些读写锁吧？

这个问题小伙伴们遇到了该如何回答呢？心里琢磨去吧，哈哈😄，不过build哥的回答要用从ReentrantReadWriteLock开始说起了，这个类也就是今天的主角，而它们同样是来自于java.util.concurrent.locks之下！

在这里插入图片描述

读写锁诞生的背景

在过去学习的过程中我们学过 synchronized、 ReentrantLock这种独占式锁，他们的好处是保证了线程的安全，缺点是同一时刻只能有一个线程持有锁，大大的影响了效率，而之前学过的Semaphore(信号量)这种呢，虽然支持同一时刻被多个线程获取，但它不能很好的保障线程安全性，我们需要的是一种效率高、安全性好的同步锁。

考虑到真正的生产生活中，对于数据的读取要比写入更为频繁，伟大的开发者们，将读数据的时候设置为共享锁，支持多个线程持有读锁，而在写的时候，考虑到线程安全，采用独占锁，同一时候仅允许一个线程持有写锁，在这种背景下读写锁应运而生！

读写锁：ReentrantReadWriteLock

ReentrantReadWriteLock是ReadWriteLock 接口的默认实现类，从名字可以看得出它也是一种具有可重入性的锁，同时也支持公平与非公平的配置，底层有两把锁，一把是 WriteLock (写锁)，一把是 ReadLock（读锁）。读锁是共享锁，写锁是独占锁。读锁可以被同时读，可以同时被多个线程持有，而写锁最多只能同时被一个线程持有，也是基于AQS实现的底层锁获取与释放逻辑。

在这里插入图片描述

内部构造

根据上面的构造图如果还没有搞清楚ReentrantReadWriteLock的底层构造的话，那我们跟入源码中取一探究竟吧！

【源码分析】

java">// 内部结构
private final ReentrantReadWriteLock.ReadLock readerLock;
private final ReentrantReadWriteLock.WriteLock writerLock;
final Sync sync;
/*1、用以继承AQS，获得AOS的特性，以及AQS的钩子函数*/
abstract static class Sync extends AbstractQueuedSynchronizer {// 具体实现
}
/*非公平模式，默认为这种模式*/
static final class NonfairSync extends Sync {// 具体实现
}
/*公平模式，通过构造方法参数设置*/
static final class FairSync extends Sync {// 具体实现
}
/*读锁，底层是共享锁*/
public static class ReadLock implements Lock, java.io.Serializable {private final Sync sync;protected ReadLock(ReentrantReadWriteLock lock) {sync = lock.sync;}// 具体实现
}
/*写锁，底层是独占锁*/
public static class WriteLock implements Lock, java.io.Serializable {private final Sync sync;protected WriteLock(ReentrantReadWriteLock lock) {sync = lock.sync;}// 具体实现
}// 构造方法，初始化两个锁
public ReentrantReadWriteLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();readerLock = new ReadLock(this);writerLock = new WriteLock(this);
}// 获取读锁和写锁的方法
public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

上面为底层的主要构造内容，ReentrantReadWriteLock中共写了5个静态内部类，各有功效，在上面的注释中也有提及。

使用案例

那么这个读写锁如何使用呢？我们写一个小小的测试案例，也感受一下。

【测试案例】

java">public class Test {private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();private int data = 0;/*** 写方法* @param value*/public void write(int value) {//注意，获取锁的操作要在try/finally外面lock.writeLock().lock(); // 获取写锁try {data = value;System.out.println("线程："+Thread.currentThread().getName() + "写" + data);} finally {lock.writeLock().unlock(); // 释放写锁}}public void read() {lock.readLock().lock(); // 获取读锁try {System.out.println("线程：" + Thread.currentThread().getName() + "读" + data);} finally {lock.readLock().unlock(); // 释放读锁}}public static void main(String[] args) {Test test = new Test();// 创建读线程Thread readThread1 = new Thread(() -> {for (int i = 0; i < 5; i++) {test.read();}});Thread readThread2 = new Thread(() -> {for (int i = 0; i < 5; i++) {test.read();}});// 创建写线程Thread writeThread = new Thread(() -> {for (int i = 0; i < 5; i++) {test.write(i);}});readThread1.start();readThread2.start();writeThread.start();try {readThread1.join();readThread2.join();writeThread.join();} catch (InterruptedException e) {e.printStackTrace();}}
}

输出：

java">线程：Thread-1读0
线程：Thread-0读0
线程：Thread-1读0
线程：Thread-2写0
线程：Thread-2写1
线程：Thread-2写2
线程：Thread-2写3
线程：Thread-0读3
线程：Thread-1读3
线程：Thread-2写4
线程：Thread-0读4
线程：Thread-1读4
线程：Thread-0读4
线程：Thread-1读4
线程：Thread-0读4