这就是读写锁（ReentrantReadWriteLock）吗？-优快云博客

个人观点，仅供参考！

一句话总结什么是读写锁：

读写锁是一种 “读写分离” 的锁机制，允许多个读操作同时执行，写操作独占执行，核心解决 “读多写少” 场景下的性能问题

一、为什么需要读写锁？

普通锁是独占锁，同一时间只能有一个线程持有锁，不管这个线程是要 “读数据” 还是 “写数据”。如果场景里大部分操作是读，少量操作是写，用普通锁会造成极大的浪费。

举个例子：

一个在线文档被 1000 个人同时查看（读），1 个人在编辑（写）。如果用普通锁，线程 A（查看者1）在读数据（查看文档）时，线程 B（查看者2）明明只是想读同样的数据（查看同一份文档），却必须等 A 释放锁才能读，大量读线程（查看者）排队等待，并发性能大幅下降。

场景	普通排他锁（ReentrantLock）	读写锁（ReentrantReadWriteLock）
一个线程写，其他读	串行（写 / 读均排队）	串行（写独占，读等待）
一个线程写，其他写	串行（写操作排队）	串行（写独占，其他写等待）
多个线程读	串行（排队执行），读操作效率低	并行（同时读），读操作效率高
多个线程读写混合	串行（所有操作排队）	读并行、写独占（读时可并行，写时阻塞所有读写）

此时，在这样的场景下（读多写少）把普通锁替换为读写锁可以显著提高并发性能。

二、读写锁的核心规则

读锁共享：无写锁时，多个线程可同时获取读锁；
写锁排他：只要有一个线程持有写锁，其他线程（读 / 写）都不能获取任何锁；
读写互斥：只要有线程持有读锁，写线程必须等所有读锁释放后才能获取写锁；
写锁可降级为读锁：同一个线程先拿写锁，再拿读锁，然后释放写锁（ReentrantReadWriteLock支持的特性）；
读锁不能升级为写锁：同一个线程先拿读锁，再拿写锁（会死锁！）。

三、Java 中的读写锁：ReentrantReadWriteLock

1、大概介绍

java在java.util.concurrent.locks包下提供了标准的读写锁实现（ReentrantReadWriteLock），核心特性：

可重入：和 ReentrantLock 一样，同一个线程可以多次加读锁 / 写锁（比如线程 A 加了读锁，还能再加读锁；线程 A 加了写锁，也能再加写锁 / 读锁）。

公平 / 非公平：默认非公平（效率高），也可以设置为公平（按排队顺序获取锁）。

// 非公平模式（默认，性能更高）
ReentrantReadWriteLock nonfairLock = new ReentrantReadWriteLock();
// 等同于：
// ReentrantReadWriteLock nonfairLock = new ReentrantReadWriteLock(false);

// 公平模式（先到先得，避免饥饿）
ReentrantReadWriteLock fairLock = new ReentrantReadWriteLock(true);

支持条件变量：写锁支持 Condition（读锁不支持）。
可中断：支持获取锁时响应中断（lockInterruptibly ()）。

ReentrantReadWriteLock 包含两个锁对象：

读锁（ReadLock）：调用readLock()获取，是 “共享锁”。
写锁（WriteLock）：调用writeLock()获取，是 “排他锁”。

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
// 获取读锁
Lock readLock = rwLock.readLock();
// 获取写锁
Lock writeLock = rwLock.writeLock();

2、核心特性

特性 1：可重入性

①写锁重入：支持，同线程可多次获取写锁。

writeLock.lock();
try {
    // 业务操作
    writeLock.lock(); // 再次获取写锁，不会死锁
    try {
        // 嵌套操作
    } finally {
        writeLock.unlock(); // 对应第二次lock
    }
} finally {
    writeLock.unlock(); // 对应第一次lock
}

②读锁重入：支持，同线程可多次获取读锁。

③写→读重入（锁降级）：支持，这是唯一允许的锁重入方向转换。

writeLock.lock(); // 先拿写锁
try {
    // 写操作：修改数据
    readLock.lock(); // 再拿读锁（锁降级）
} finally {
    writeLock.unlock(); // 释放写锁（此时读锁还持有，保证其他线程读不到脏数据）
}
try {
    // 读操作：读取修改后的数据
} finally {
    readLock.unlock(); // 释放读锁
}

④读→写重入（锁升级）：不支持，会阻塞（设计如此，防止死锁）。

特性 2：公平 / 非公平模式

①默认非公平（性能更高）。

②可通过构造参数设置为公平模式。

特性 3：锁的状态管理（底层原理，先理解概念）

基于 AQS 的 32 位 state 拆分：高 16 位：读锁计数（共享锁）；低 16 位：写锁计数（独占锁）。

特性 4：条件变量

①只有写锁支持 Condition。

②读锁调用 newCondition () 会抛 UnsupportedOperationException。

特性 5：可中断锁获取

①使用 lockInterruptibly () 可响应中断。

②普通 lock () 不响应中断（会设置中断标志但继续等待）。

try {
    readLock.lockInterruptibly(); // 可中断的读锁获取
    // 或 writeLock.lockInterruptibly();
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 恢复中断状态
    return;
}

特性 6：尝试获取锁

①tryLock () 立即返回。

②tryLock (timeout, unit) 超时等待。

③公平模式下 tryLock () 不遵守公平原则。

if (writeLock.tryLock(1, TimeUnit.SECONDS)) { // 尝试1秒获取写锁
    try {
        // 写操作
    } finally {
        writeLock.unlock();
    }
} else {
    // 获取锁失败，做降级处理
}

3、常用 API

方法 / 属性	所属锁	作用
lock()	读 / 写锁	获取锁，阻塞直到获取成功
unlock()	读 / 写锁	释放锁
lockInterruptibly()	读 / 写锁	可中断地获取锁
tryLock()	读 / 写锁	尝试获取锁，立即返回 boolean
tryLock(long, TimeUnit)	读 / 写锁	超时尝试获取锁
newCondition()	写锁	创建条件变量（读锁调用抛异常）
isFair()	读写锁对象	判断是否是公平锁
getReadLockCount()	读写锁对象	获取当前读锁的总持有数（包括重入）
getWriteHoldCount()	读写锁对象	获取当前线程持有写锁的次数（重入次数）
isWriteLocked()	读写锁对象	判断是否有线程持有写锁
getQueueLength()	读写锁对象	获取等待获取锁的线程数