共计 4839 个字符，预计需要花费 13 分钟才能阅读完成。
Java 并发编程提供了读写锁，次要用于读多写少的场景，明天我就重点来解说读写锁的底层实现原理 @mikechen
什么是读写锁？
读写锁并不是 JAVA 所特有的读写锁（Readers-Writer Lock）顾名思义是一把锁分为两局部：读锁和写锁，其中读锁容许多个线程同时取得，因为读操作自身是线程平安的，而写锁则是互斥锁，不容许多个线程同时取得写锁，并且写操作和读操作也是互斥的。
所谓的读写锁（Readers-Writer Lock），顾名思义就是将一个锁拆分为读锁和写锁两个锁。
其中读锁容许多个线程同时取得，而写锁则是互斥锁，不容许多个线程同时取得写锁，并且写操作和读操作也是互斥的。
为什么须要读写锁？
Synchronized 和 ReentrantLock 都是独占锁，即在同一时刻只有一个线程获取到锁。
然而在有些业务场景中，咱们大多在读取数据，很少写入数据，这种状况下，如果仍应用独占锁，效率将及其低下。
针对这种状况，Java 提供了读写锁——ReentrantReadWriteLock。
次要解决：对共享资源有读和写的操作，且写操作没有读操作那么频繁的场景。
读写锁的特点
- 公平性：读写锁反对非偏心和偏心的锁获取形式，非偏心锁的吞吐量优于偏心锁的吞吐量，默认结构的是非偏心锁
- 可重入：在线程获取读锁之后可能再次获取读锁，然而不能获取写锁，而线程在获取写锁之后可能再次获取写锁，同时也能获取读锁
- 锁降级：线程获取写锁之后获取读锁，再开释写锁，这样实现了写锁变为读锁，也叫锁降级
\
读写锁的应用场景
ReentrantReadWriteLock 适宜读多写少的场景：
读锁 ReentrantReadWriteLock.ReadLock 能够被多个线程同时持有, 所以并发能力很高。
写锁 ReentrantReadWriteLock.WriteLock 是独占锁, 在一个线程持有写锁时候, 其余线程都不能在抢占, 蕴含抢占读锁都会阻塞。
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 实现关键点，次要包含：
- 读写状态的设计
- 写锁的获取与开释
- 读锁的获取与开释
- 锁降级
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 acquire
setState(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 的特色、实现、锁的获取过程，通过 4 个关键点的外围设计：
- 读写状态的设计
- 写锁的获取与开释
- 读锁的获取与开释
- 锁降级
从而能力实现：共享资源有读和写的操作，且写操作没有读操作那么频繁的利用场景。
作者简介
陈睿 |mikechen,10 年 + 大厂架构教训,《BAT 架构技术 500 期》系列文章作者，专一于互联网架构技术。
浏览 mikechen 的互联网架构更多技术文章合集
Java 并发 |JVM|MySQL|Spring|Redis| 分布式 | 高并发
关注「mikechen 的互联网架构」公众号，回复 【架构】 支付《Java 进阶架构思维导图 &Java 进阶架构文章合集》