java并发-ReentrantReadWriteLock读写锁

文章目录

介绍
读写锁的获取规则
示例
源码解读
- ReentrantReadWriteLock核心变量
- ReentrantReadWriteLock相关属性和构造函数
- Sync静态内部类的核心属性
- tryAcquireShared方法
- tryAcquire方法
- 锁降级
总结

介绍

读写锁就是将一个锁拆分为读锁和写锁两个锁。

读写锁的获取规则

如果有一个线程已经占用了读锁，则此时其他线程如果要申请读锁，可以申请成功。
如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁，因为读写不能同时操作。
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，都必须等待之前的线程释放写锁，同样也因为读写不能同时，并且两个线程不应该同时写。

总之，要么是一个或多个线程同时有读锁，要么是一个线程有写锁，但是两者不会同时出现。也可以总结为：读读共享、其他都互斥（写写互斥、读写互斥、写读互斥）。

示例

public class ReadWriteLockDemo {private static final ReentrantReadWriteLock reentrantReadWriteLock = newReentrantReadWriteLock(false);private static final ReentrantReadWriteLock.ReadLock readLock =reentrantReadWriteLock.readLock();private static final ReentrantReadWriteLock.WriteLock writeLock =reentrantReadWriteLock.writeLock();private static void read() {readLock.lock();try {System.out.println(Thread.currentThread().getName() + "得到读锁，正在读取");Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println(Thread.currentThread().getName() + "释放读锁");readLock.unlock();}}private static void write() {writeLock.lock();try {System.out.println(Thread.currentThread().getName() + "得到写锁，正在写入");Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println(Thread.currentThread().getName() + "释放写锁");writeLock.unlock();}}public static void main(String[] args) throws InterruptedException {new Thread(() -> read()).start();new Thread(() -> read()).start();new Thread(() -> write()).start();new Thread(() -> write()).start();}
}

得到的运行结果

Thread-0得到读锁，正在读取
Thread-1得到读锁，正在读取
Thread-0释放读锁
Thread-1释放读锁
Thread-2得到写锁，正在写入
Thread-2释放写锁
Thread-3得到写锁，正在写入
Thread-3释放写锁

读写锁适用场合:适用于一般场合，ReadWriteLock 适用于读多写少的情况，合理使用可以进一步提高并发效率。

源码解读

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();
}

ReentrantReadWriteLock核心变量

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

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);
}

Sync静态内部类的核心属性

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;
}

tryAcquireShared方法

该方法其目的是尝试获取共享锁。

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

int c = getState();: 获取当前锁的状态值。在共享模式中，这个状态值通常表示持有锁的线程数量或其他相关信息。
int nextc = c + (1 << 16);: 计算下一个状态值，这里是将当前状态值增加（左移）16位。在共享模式中，通常用高16位表示持有锁的线程数量。
if (nextc < c) { throw new Error("Maximum lock count exceeded"); }: 检查是否超过了最大锁数量，如果超过了，抛出一个错误。这是一个防止溢出的保护措施。
if (exclusiveCount(c) != 0 && owner != Thread.currentThread()) return -1;: 检查是否有线程持有独占锁（exclusiveCount© != 0），如果有且不是当前线程，则返回-1表示获取失败。这是因为共享锁和独占锁通常不能同时持有，这里保证了只有在没有独占锁被持有时，才能获取共享锁。
if (compareAndSetState(c, nextc)) return 1;: 使用原子操作尝试将状态值更新为nextc。如果成功，表示获取锁成功，返回1。这里使用了 compareAndSetState 方法，该方法通常是一个原子的比较并设置操作，用于确保在并发情况下只有一个线程可以成功修改状态值。

tryAcquire方法

该方法尝试获取独占锁（写锁）

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;
}

解释：

Thread current = Thread.currentThread();: 获取当前线程。
int c = getState();: 获取当前同步状态。
int w = exclusiveCount(c);: 获取独占锁（写锁）的被获取的数量。
if (c != 0) { ... }: 如果当前同步状态不为0，表示有读锁或者写锁已经被持有。

如果写锁数量为0或者当前拥有写锁的线程不是当前线程，则返回false表示获取锁失败。
如果写锁数量不为0且当前拥有写锁的线程是当前线程，表示是重入获取锁。检查是否会超过最大锁数量，如果超过则抛出异常，否则更新同步状态并返回true。

如果当前同步状态为0，表示没有读锁被持有，进入这个分支。

writerShouldBlock(): 检查是否应该阻塞写锁，根据具体实现。
compareAndSetState(c, c + acquires): 使用CAS原子操作尝试获取锁。如果获取失败，表示有其他线程同时竞争锁，返回false。
如果成功获取锁，设置当前线程为独占锁的拥有者，并返回true。