我们继续Java多线程与并发系列之旅，之前我们分享了Synchronized 和 ReentrantLock 都是独占锁，即在同一时刻只有一个线程获取到锁。

然而在有些业务场景中，我们大多在读取数据，很少写入数据，这种情况下，如果仍使用独占锁，效率将及其低下。

针对这种情况，Java提供了读写锁——ReentrantReadWriteLock。

有点类似MySQL数据库为代表的读写分离机制，既然我们知道了读写锁是用于读多写少的场景。那问题来了，ReentrantReadWriteLock是怎样来实现的呢，它与ReentrantLock的实现又有什么的区别呢？

带着这些疑问，Mike将通过本篇为大家剖析其中的缘由。

本文作者：MikeChen，10年+大厂架构师、CTO，持续创作、免费分享【BAT架构技术专题500+期】。

文章目录

ReentrantReadWriteLock简介
ReentrantReadWriteLock特性
ReentrantReadWriteLock的主要成员
ReentrantReadWriteLock的实现原理
ReentrantReadWriteLock写锁和读锁的获取与释放

ReentrantReadWriteLock简介

很多情况下有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。

在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源，但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。

针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁。

ReentrantReadWriteLock特性

公平性：读写锁支持非公平和公平的锁获取方式，非公平锁的吞吐量优于公平锁的吞吐量，默认构造的是非公平锁
可重入：在线程获取读锁之后能够再次获取读锁，但是不能获取写锁，而线程在获取写锁之后能够再次获取写锁，同时也能获取读锁
锁降级：线程获取写锁之后获取读锁，再释放写锁，这样实现了写锁变为读锁，也叫锁降级

ReentrantReadWriteLock的主要成员和结构图

1. ReentrantReadWriteLock的继承关系

public interface ReadWriteLock {/*** Returns the lock used for reading.** @return the lock used for reading.*/Lock readLock（）;/*** Returns the lock used for writing.** @return the lock used for writing.*/Lock writeLock（）;
}

读写锁 ReadWriteLock

读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。

只要没有写入，读取锁可以由多个读线程同时保持,写入锁是独占的。

2.ReentrantReadWriteLock的核心变量

ReentrantReadWriteLock类包含三个核心变量：

ReaderLock：读锁,实现了Lock接口
WriterLock：写锁,也实现了Lock接口
Sync：继承自AbstractQueuedSynchronize（AQS）,可以为公平锁FairSync 或非公平锁NonfairSync

3.ReentrantReadWriteLock的成员变量和构造函数

 /** 内部提供的读锁 */private final ReentrantReadWriteLock.ReadLock readerLock;/** 内部提供的写锁 */private final ReentrantReadWriteLock.WriteLock writerLock;/** AQS来实现的同步器 */final Sync sync;/*** Creates a new {@code ReentrantReadWriteLock} with* 默认创建非公平的读写锁*/public ReentrantReadWriteLock（） {this（false）;}/*** Creates a new {@code ReentrantReadWriteLock} with* the given fairness policy.** @param fair {@code true} if this lock should use a fair ordering policy*/public ReentrantReadWriteLock（boolean fair） {sync = fair ? new FairSync（） : new NonfairSync（）;readerLock = new ReadLock（this）;writerLock = new WriteLock（this）;}

ReentrantReadWriteLock的核心实现

ReentrantReadWriteLock实现关键点，主要包括：

读写状态的设计
写锁的获取与释放
读锁的获取与释放
锁降级

1.读写状态的设计

之前谈ReentrantLock的时候,Sync类是继承于AQS，主要以int state为线程锁状态,0表示没有被线程占用，1表示已经有线程占用。

同样ReentrantReadWriteLock也是继承于AQS来实现同步，那int state怎样同时来区分读锁和写锁的？

如果在一个整型变量上维护多种状态，就一定需要“按位切割使用”这个变量，ReentrantReadWriteLock将int类型的state将变量切割成两部分：

高16位记录读锁状态
低16位记录写锁状态

abstract static class Sync extends AbstractQueuedSynchronizer {// 版本序列号private static final long serialVersionUID = 6317671515068378041L;        // 高16位为读锁，低16位为写锁static final int SHARED_SHIFT   = 16;// 读锁单位static final int SHARED_UNIT    = （1 << SHARED_SHIFT）;// 读锁最大数量static final int MAX_COUNT      = （1 << SHARED_SHIFT） - 1;// 写锁最大数量static final int EXCLUSIVE_MASK = （1 << SHARED_SHIFT） - 1;// 本地线程计数器private transient ThreadLocalHoldCounter readHolds;// 缓存的计数器private transient HoldCounter cachedHoldCounter;// 第一个读线程private transient Thread firstReader = null;// 第一个读线程的计数private transient int firstReaderHoldCount;
}

2.写锁的获取与释放

protected final boolean tryAcquire（int acquires） {/** Walkthrough:* 1. If read count nonzero or write count nonzero*    and owner is a different thread, fail.* 2. If count would saturate, fail. （This can only*    happen if count is already nonzero.）* 3. Otherwise, this thread is eligible for lock if*    it is either a reentrant acquire or*    queue policy allows it. If so, update state*    and set owner.*/Thread current = Thread.currentThread（）;int c = getState（）;//获取独占锁（写锁）的被获取的数量int w = exclusiveCount（c）;if （c != 0） {// （Note: if c != 0 and w == 0 then shared count != 0）//1.如果同步状态不为0，且写状态为0,则表示当前同步状态被读锁获取//2.或者当前拥有写锁的线程不是当前线程if （w == 0 || current != getExclusiveOwnerThread（））return false;if （w + exclusiveCount（acquires） > MAX_COUNT）throw new Error（"Maximum lock count exceeded"）;// Reentrant acquiresetState（c + acquires）;return true;}if （writerShouldBlock（） ||!compareAndSetState（c, c + acquires））return false;setExclusiveOwnerThread（current）;return true;}

1）c是获取当前锁状态,w是获取写锁的状态。

2）如果锁状态不为零，而写锁的状态为0，则表示读锁状态不为0，所以当前线程不能获取写锁。或者锁状态不为零，而写锁的状态也不为0，但是获取写锁的线程不是当前线程，则当前线程不能获取写锁。

3）写锁是一个可重入的排它锁，在获取同步状态时，增加了一个读锁是否存在的判断。

写锁的释放与ReentrantLock的释放过程类似，每次释放将写状态减1，直到写状态为0时，才表示该写锁被释放了。

3.读锁的获取与释放

protected final int tryAcquireShared（int unused） {for（;;） {int c = getState（）;int nextc = c + （1<<16）;if（nextc < c） {throw new Error（"Maxumum lock count exceeded"）;}if（exclusiveCount（c）!=0 && owner != Thread.currentThread（））return -1;if（compareAndSetState（c,nextc））return 1;}
}

1）读锁是一个支持重进入的共享锁，可以被多个线程同时获取。

2）在没有写状态为0时，读锁总会被成功获取，而所做的也只是增加读状态（线程安全）

3）读状态是所有线程获取读锁次数的总和，而每个线程各自获取读锁的次数只能选择保存在ThreadLocal中，由线程自身维护。

读锁的每次释放均减小状态（线程安全的，可能有多个读线程同时释放锁），减小的值是1<<16。

4.锁降级

降级是指当前把持住写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。

锁降级过程中的读锁的获取是否有必要，答案是必要的。主要是为了保证数据的可见性，如果当前线程不获取读锁而直接释放写锁，假设此刻另一个线程获取的写锁，并修改了数据，那么当前线程就步伐感知到线程T的数据更新，如果当前线程遵循锁降级的步骤，那么线程T将会被阻塞，直到当前线程使数据并释放读锁之后，线程T才能获取写锁进行数据更新。

5.读锁与写锁的整体流程

ReentrantReadWriteLock总结

本篇详细介绍了ReentrantReadWriteLock的特征、实现、锁的获取过程，通过4个关键点的核心设计：

读写状态的设计
写锁的获取与释放
读锁的获取与释放
锁降级

从而才能实现：共享资源有读和写的操作，且写操作没有读操作那么频繁的应用场景。

你可能也喜欢:

Redis系列教程(八)：分布式锁的由来、及Redis分布式锁的实现详解
Java多线程系列（八）：ConcurrentHashMap的实现原理（JDK1.7和JDK1.8）
Java多线程系列（一）：最全面的Java多线程学习概述
Java多线程系列（六）：深入详解Synchronized同步锁的底层实现
Java多线程系列（十）：源码剖析AQS的实现原理
Java多线程系列(四)：4种常用Java线程锁的特点，性能比较、使用场景

Java多线程系列(十一)：ReentrantReadWriteLock的实现原理与锁获取详解相关推荐

java一个方法排他调用_Java编程实现排他锁代码详解
一 .前言某年某月某天,同事说需要一个文件排他锁功能,需求如下: (1)写操作是排他属性 (2)适用于同一进程的多线程/也适用于多进程的排他操作 (3)容错性:获得锁的进程若Crash,不影响到后续 ...
java 方法继承方法_java的继承原理与实现方法详解
本文实例讲述了java的继承原理与实现方法.分享给大家供大家参考,具体如下: 继承 1.java中是单继承的.每个子类只有一个父类. 语法:子类 extends 父类 2.在java中,即使没有声明父 ...
Java多线程系列(八)：ConcurrentHashMap的实现原理(JDK1.7和JDK1.8)
HashMap.CurrentHashMap 的实现原理基本都是BAT面试必考内容,阿里P8架构师谈:深入探讨HashMap的底层结构.原理.扩容机制深入谈过hashmap的实现原理以及在JDK 1. ...
Java多线程系列(三)：Java线程池的使用方式，及核心运行原理
之前谈过多线程相关的4种常用Java线程锁的特点,性能比较.使用场景,今天主要分享线程池相关的内容,这些都是属于Java面试的必考点. 为什么需要线程池 java中为了提高并发度,可以使用多线程共同执 ...
Java多线程系列(四)：4种常用Java线程锁的特点，性能比较、使用场景
多线程的缘由在出现了进程之后,操作系统的性能得到了大大的提升.虽然进程的出现解决了操作系统的并发问题,但是人们仍然不满足,人们逐渐对实时性有了要求. 使用多线程的理由之一是和进程相比,它是一种非常花 ...
Java多线程系列(九)：CountDownLatch、Semaphore等4大并发工具类详解
之前谈过高并发编程系列:4种常用Java线程锁的特点,性能比较.使用场景 ,以及高并发编程系列:ConcurrentHashMap的实现原理(JDK1.7和JDK1.8) 今天主要介绍concurre ...
Java多线程系列--AQS的原理
原文网址:Java多线程系列--AQS的原理_IT利刃出鞘的博客-CSDN博客简介本文介绍Java中的AQS的原理. Java的AQS是JDK自带的锁机制,是JUC(java.util.concu ...
Java多线程系列(七)：并发容器的原理，7大并发容器详解、及使用场景
之前谈过高并发编程系列: 高并发编程系列:4种常用Java线程锁的特点,性能比较.使用场景高并发编程系列:CountDownLatch.Semaphore等4大并发工具类详解高并发编程系列:4大J ...
Java多线程系列(五)：线程池的实现原理、优点与风险、以及四种线程池实现
为什么需要线程池我们有两种常见的创建线程的方法,一种是继承Thread类,一种是实现Runnable的接口,Thread类其实也是实现了Runnable接口.但是我们创建这两种线程在运行结束后都会被 ...

Java多线程系列(十一)：ReentrantReadWriteLock的实现原理与锁获取详解