在Java并发编程的浩瀚海洋里ReentrantReadWriteLock无疑是一艘坚固的战舰。hen多朋友在面试或者实际开发中dou接触过它，但真正沉下心来去剖析它源码的人，恐怕就不多了。说实话，读源码是一件枯燥但又充满惊喜的事情，就像是在拆解一个精密的钟表，每一个齿轮的咬合dou让人叹为观止。今天我们就抛开那些晦涩的教条，用一种geng轻松、geng贴近实战的视角，把这个类的“五脏六腑”dou翻出来kankan。

我们要聊的不仅仅是代码，而是代码背后的设计哲学。为什么它要这么设计？它是如何在一个int变量里同时塞进读锁和写锁的状态的？又是如何保证公平性的？别急，我们慢慢来。

我们得先搞清楚ReentrantReadWriteLock的家族谱系。这个类实现了ReadWriteLock接口，这意味着它必须遵守读写锁的规范：一把读锁，一把写锁。但是Ru果你点开它的源码，会发现它其实是一个“组合拳”大师。

它内部定义了五个核心的内部类，它们之间错综复杂却又井然有序：

Sync这是一个抽象类，继承自大名鼎鼎的AbstractQueuedSynchronizer。Ke以说它是整个锁机制的基石，所有的状态管理、队列排队dou依赖它。

FairSync和NonfairSync这两个是Sync的具体实现，分别代表了公平锁和非公平锁策略。

ReadLock和WriteLock这两个实现了Lock接口，分别对应我们日常使用的读锁和写锁，它们内部持有了Sync的引用。

kan到这里你可Neng会想：为什么要搞这么复杂？其实这种分层设计正是JDK源码的精髓所在把策略和具体实现分离开来维护起来才不会乱成一锅粥。

接下来我们聊聊Zui让人头疼，也Zui让人着迷的部分：状态管理。在AQS中，通常用一个state变量来表示锁的状态。但是读写锁有两个锁啊？难道定义两个变量？

当然不是！JDK的大师们想出了一个绝妙的办法：位运算。他们把一个32位的整数state切成了两半。

具体来说高16位用来存“读锁”的持有数量，低16位用来存“写锁”的重入次数。这就像是在一个房间里划了两个区域，左边住着读锁，右边住着写锁，互不干扰。

源码里定义了几个常量来辅助这种切分：

// 高16位为读锁，低16位为写锁
static final int SHARED_SHIFT   = 16;
// 读锁单位，也就是1左移16位
static final int SHARED_UNIT    = ;
// 读锁Zui大数量
static final int MAX_COUNT      =  - 1;
// 写锁Zui大数量，也是低16位的掩码
static final int EXCLUSIVE_MASK =  - 1;

那么我们怎么知道现在有几个读锁，几个写锁呢？这就用到了两个静态工具方法：

// 返回读锁的持有数量，直接无符号右移16位
static int sharedCount    { return c>> SHARED_SHIFT; }
// 返回写锁的持有数量，直接与掩码Zuo与运算
static int exclusiveCount { return c & EXCLUSIVE_MASK; }

是不是hen巧妙？通过c & EXCLUSIVE_MASK，我们Ke以把高16位全部抹去，只留下低16位的写锁信息。这种设计不仅节省了内存，还保证了操作的原子性，毕竟CAS操作只Neng针对一个变量嘛。

写锁是独占锁，它的性格比较霸道：只要我拿到了锁，其他人dou别想进来；Ru果别人拿着锁，我也只Neng在门口等着。我们来kankan它的核心获取逻辑tryAcquire。

protected final boolean tryAcquire {
    Thread current = Thread.currentThread;
    int c = getState;
    int w = exclusiveCount; // 拿到写锁的个数
    // 1. Ru果状态不为0，说明锁被占用了
    if  {
        // 
        // Ru果写锁个数为0，或者当前线程不是独占线程
        // 这两种情况dou直接失败
        if )
            return false;
        // 检查重入次数是否溢出
        if > MAX_COUNT)
            throw new Error;
        // 重入获取，直接修改状态
        setState;
        return true;
    }
    // 2. Ru果状态为0，说明没人占锁
    // 判断是否需要阻塞，然后尝试CAS抢锁
    if  ||
        !compareAndSetState)
        return false;
    // 抢锁成功，设置独占线程
    setExclusiveOwnerThread;
    return true;
}

这段代码的逻辑非常清晰： 1. 有人占锁时Ru果是读锁占着，或者写锁占着但不是自己，直接走人；Ru果是自己占着，那就计数加1。 2. 没人占锁时kankan是不是公平策略。Ru果是非公平锁，直接冲上去CAS抢；Ru果是公平锁，得kankan队列里有没有排队的“老大哥”，有就得让着点。

释放写锁的逻辑tryRelease就简单多了就是减去重入次数，Ru果减完变成0了就把独占线程清空。

读锁是共享锁，它的性格比较随和：只要没有写锁在捣乱，大家douKe以一起读。但是读锁的计数逻辑比写锁复杂得多，因为它要记录每个线程到底重入了多少次。

这里引入了一个HoldCounter类，它专门用来记录某个线程的重入次数。为了性Neng优化，还引入了firstReader和cachedHoldCounter。

我们来kankantryAcquireShared的精妙之处：

protected final int tryAcquireShared {
    Thread current = Thread.currentThread;
    int c = getState;
    // 1. Ru果写锁被占用，且占用者不是当前线程，直接失败
    // 
    if  != 0 &&
        getExclusiveOwnerThread != current)
        return -1;
    int r = sharedCount; // 读锁数量
    // 2. 检查是否需要阻塞，且读锁数未溢出，且CAS修改状态成功
    if  &&
        r 

public ReentrantReadWriteLock {
    sync = fair ? new FairSync : new NonfairSync;
    readerLock = new ReadLock;
    writerLock = new WriteLock;
}

public final boolean hasQueuedPredecessors {
    Node t = tail; 
    Node h = head;
    Node s;
    return h != t &&
         == null || s.thread != Thread.currentThread);
}

public class ReentrantReadWriteLockTest {
    public static void main {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock;
        ReadThread read1 = new ReadThread;
        ReadThread read2 = new ReadThread;
        WriteThread write1 = new WriteThread;
        read1.start;
        read2.start;
        write1.start;
    }
}
class WriteThread extends Thread {
    private ReentrantReadWriteLock lock;
    public WriteThread {
        super;
        this.lock = lock;
    }
    @Override
    public void run {
        System.out.println.getName + " start trying to lock");
        try {
            lock.writeLock.lock;
            System.out.println.getName + " 获取写锁成功");
            Thread.sleep; // 模拟耗时操作
        } catch  {
            e.printStackTrace;
        } finally {
            lock.writeLock.unlock;
            System.out.println.getName + " 释放写锁成功");
        }
    }
}
class ReadThread extends Thread {
    private ReentrantReadWriteLock lock;
    public ReadThread {
        super;
        this.lock = lock;
    }
    @Override
    public void run {
        System.out.println.getName + " trying to lock");
        try {
            lock.readLock.lock;
            System.out.println.getName + " 获取读锁成功");
            Thread.sleep; 
        } catch  {
            e.printStackTrace;
        } finally {
            lock.readLock.unlock;
            System.out.println.getName + " 释放读锁成功");
        }
    }
}