深入分析实战可重入读写锁ReentrantReadWriteLock

文章目录

前言
加锁规则
同步原理
源码解析
实战演示

前言

前面我们学习了可重入锁ReentrantLock，可重入锁是一个排他锁，只要不是当前线程访问加锁资源都不能够进入，只能等待锁的释放。当然，这种加锁方式也有一定的适用场景。但是，如果在读多写少的情况下可重入锁ReentrantLock可能不是那么完美，比如缓存的写入和读取。今天，我们就引出可重入读写锁ReentrantReadWriteLock，其读写分离的机制，大大提升缓存场景的系统性能。

加锁规则

可重入锁ReentrantReadWriteLock内部分为读锁和写锁，读锁与写锁的加锁规则如下：

锁类型	读锁	写锁
读锁	共享	互斥
写锁	互斥	互斥

同步原理

可重入锁ReentrantReadWriteLock的同步机制依然是继承抽象同步队列AQS，其内部实现了自身的读锁与写锁的规则，覆写了AQS的一些同步标识和方法。其本质上都是使用AQS同步原理，并用AQS的阻塞队列保存阻塞线程，用AQS的STATE来表示当前锁状态，可重入本质上也是加减STATE来达到对应的目的。

源码解析

进入 package java.util.concurrent.locks 查看可重入ReentrantReadWriteLock源码：

public class ReentrantReadWriteLockimplements ReadWriteLock, java.io.Serializable {private static final long serialVersionUID = -6992448646407690164L;/** Inner class providing readlock */private final ReentrantReadWriteLock.ReadLock readerLock;/** Inner class providing writelock */private final ReentrantReadWriteLock.WriteLock writerLock;/** Performs all synchronization mechanics */final Sync sync;/*** Creates a new {@code ReentrantReadWriteLock} with* default (nonfair) ordering properties.*/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);}public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
}

如上源码所示，可重入读写锁实现了读写锁ReadWriteLock，保留读写锁的机制，增加了可重入机制。调用方可以通过传入标识实现非公平锁和公平锁来保证同步，当然可重入读写锁默认NonfairSync非公平锁同步。

继续查看源码：

//内部类继承抽象同步队列
abstract static class Sync extends AbstractQueuedSynchronizer{//加解锁省略
}//公平锁
static final class FairSync extends Sync {private static final long serialVersionUID = -2274990926593161451L;final boolean writerShouldBlock() {return hasQueuedPredecessors();}final boolean readerShouldBlock() {return hasQueuedPredecessors();}
}
//非公平锁
static final class NonfairSync extends Sync {private static final long serialVersionUID = -8159625535654395037L;final boolean writerShouldBlock() {return false; // writers can always barge}final boolean readerShouldBlock() {/* As a heuristic to avoid indefinite writer starvation,* block if the thread that momentarily appears to be head* of queue, if one exists, is a waiting writer.  This is* only a probabilistic effect since a new reader will not* block if there is a waiting writer behind other enabled* readers that have not yet drained from the queue.*/return apparentlyFirstQueuedIsExclusive();}
}//获取读锁
public static class ReadLock implements Lock, java.io.Serializable {private static final long serialVersionUID = -5992448646407690164L;private final Sync sync;/*** Constructor for use by subclasses** @param lock the outer lock object* @throws NullPointerException if the lock is null*/protected ReadLock(ReentrantReadWriteLock lock) {sync = lock.sync;}//加解锁省略
}//写锁
public static class WriteLock implements Lock, java.io.Serializable {private static final long serialVersionUID = -4992448646407690164L;private final Sync sync;/*** Constructor for use by subclasses** @param lock the outer lock object* @throws NullPointerException if the lock is null*/protected WriteLock(ReentrantReadWriteLock lock) {sync = lock.sync;}//加解锁省略
}

如上源码所示，可重入读写锁公平与非公平锁都集成内部类Sync，本质上还是继承至AQS。ReentrantReadWriteLock的读锁与写锁都是实现Lock,并覆写了其增加解锁的方法；对于锁机制的同步规则则是直接传入内部类Sync。

由此可知，可重入读写锁ReentrantReadWriteLock的加锁方法来源是Lock，同步机制来源与抽象同步队列AQS。当然对于可重入读写锁为保证读锁与写锁、写锁与写锁的互斥，覆写了AQS的同步方法，加入了满足自身规则的一些方法。

继续查看获取锁的源码：

//尝试获取共享锁
protected final int tryAcquireShared(int unused) {/** 1. 如果是写锁持有资源，其他线程直接返回失败* 2. 如果没有资源没有加写锁，则会检查资源的锁定状态，并尝试用cas修改state状态* 3. 如果第二步失败，则表示当前线程没有获取锁资格或者cas修改state失败，则该线程会重试。*/Thread current = Thread.currentThread();int c = getState();if (exclusiveCount(c) != 0 &&getExclusiveOwnerThread() != current)return -1;int r = sharedCount(c);if (!readerShouldBlock() &&r < MAX_COUNT &&compareAndSetState(c, c + SHARED_UNIT)) {if (r == 0) {firstReader = current;firstReaderHoldCount = 1;} else if (firstReader == current) {firstReaderHoldCount++;} else {HoldCounter rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current))cachedHoldCounter = rh = readHolds.get();else if (rh.count == 0)readHolds.set(rh);rh.count++;}return 1;}return fullTryAcquireShared(current);
}/*** 重试获取共享锁，相比之前的方法更为简单的验证锁和cas修改state*/
final int fullTryAcquireShared(Thread current) {HoldCounter rh = null;for (;;) {int c = getState();if (exclusiveCount(c) != 0) {if (getExclusiveOwnerThread() != current)return -1;// else we hold the exclusive lock; blocking here// would cause deadlock.} else if (readerShouldBlock()) {// Make sure we're not acquiring read lock reentrantlyif (firstReader == current) {// assert firstReaderHoldCount > 0;} else {if (rh == null) {rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current)) {rh = readHolds.get();if (rh.count == 0)readHolds.remove();}}if (rh.count == 0)return -1;}}if (sharedCount(c) == MAX_COUNT)throw new Error("Maximum lock count exceeded");if (compareAndSetState(c, c + SHARED_UNIT)) {if (sharedCount(c) == 0) {firstReader = current;firstReaderHoldCount = 1;} else if (firstReader == current) {firstReaderHoldCount++;} else {if (rh == null)rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current))rh = readHolds.get();else if (rh.count == 0)readHolds.set(rh);rh.count++;cachedHoldCounter = rh; // cache for release}return 1;}}
}

如上源码所示，获取共享锁的源码主要是验证当前资源是否已经被加写锁，如果加了写锁其他线程会互斥不能获取该锁；如果没有加写锁则会进行加锁资格验证，读锁则可以共享加锁。在验证当前线程有加锁资格后，程序会用CAS修改STATE状态以保证可重入和释放锁机制的正常运行。

当然，如果当前线程之前是加了写锁，现在该线程对资源加读锁，那么此时当前写锁会进行降级为读锁。但是，反之当前线程加了读锁，然后该线程又对资源加写锁是不被支持的，因为这样会造成死锁。

实战演示

虽然可重入读写锁ReentrantReadWriteLock在实际生产中使用的场景较少，但是还是有它的一席之地的。话说有需要才会存在，可重入读写锁对我们生产的缓存操作极其重要。

以下我将就缓存的读写进行代码演示，当然也是因为引入可重入读写锁会使得缓存操作效率更高。

/*** ReentrantReadWriteLockDemo* @author senfel* @version 1.0* @date 2023/5/22 10:48*/
@Slf4j
public class ReentrantReadWriteLockDemo {private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();/*** 用内存缓存模拟*/private static final Map<String,String> cache  = new HashMap<>();/*** 获取缓存* @param key* @author senfel* @date 2023/5/22 14:44* @return java.lang.String*/public static String getValue(String key){//加读锁获取缓存try{readWriteLock.readLock().lock();String str = cache.get(key);if(StringUtils.isNotBlank(str)){return str;}}catch (Exception e){log.error("获取缓存异常：{}",e.getStackTrace());}finally {readWriteLock.readLock().unlock();}//没有获取到写入缓存，需要加写锁try {readWriteLock.writeLock().lock();//加写锁成功，再次验证是否存在缓存String str = cache.get(key);if(StringUtils.isNotBlank(str)){return str;}else{//查询数据库获取缓存，这里模拟设置一个常量标识以获取缓存str = "senfel";cache.put(key,str);return str;}}catch (Exception e){log.error("获取缓存异常：{}",e.getStackTrace());}finally {readWriteLock.writeLock().unlock();}return null;}/*** 设置缓存* @param key* @author senfel* @date 2023/5/22 14:44* @return java.lang.String*/public void setValue(String key,String value){try{readWriteLock.writeLock().lock();cache.put(key,value);}catch (Exception e){log.error("设置缓存异常：{}",e.getStackTrace());}finally {readWriteLock.writeLock().unlock();}}
}