Java 读写锁 ReadWriteLock 原理与应用场景详解_java读写锁

什么是读写锁？
读写锁并不是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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

复制代码

读写锁的实现原理
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©;
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(;