ReentrantReadWriteLock源码解析

简介

ReentrantReadWriteLock是juc包下的一个读写锁工具类，该类内部维护着一个读锁和一个写锁，通过读锁与写锁的分离使得在读多写少的坏境下性能有了很好的提升，可以减少线程的总等待时间。
注意点：

读读不阻塞，同一时间可以允许多个线程进行读锁的获取。
读写、写读阻塞，也就是读锁被线程获取的时候，其他线程不能获取写锁，写锁被线程获取的时候其他线程不能进行读锁的获取。

主要特性：
1.公平性，ReentrantReadWriteLock构造函数支持公平以及非公平模式。
2.可重入性，ReentrantReadWriteLock读锁与写锁都支持锁的重入功能。
3.锁降级，ReentrantReadWriteLock在获取写锁的同时可以重入读锁，然后释放锁的时候先释放写锁以达到锁的降级。（注意ReentrantReadWriteLock只能进行锁降级不能进行锁升级，锁升级的时候会无限等待进入死锁）

ReentrantReadWriteLock内部结构

/*内部读锁*/
private final ReentrantReadWriteLock.ReadLock readerLock;
/*内部写锁*/
private final ReentrantReadWriteLock.WriteLock writerLock;
/*无参构造器 默认是给公平模式*/
public ReentrantReadWriteLock();
/*公平模式构造器*/
public ReentrantReadWriteLock(boolean fair);
/*获取写锁方法*/
public ReentrantReadWriteLock.WriteLock writeLock();
/*获取读锁方法*/
public ReentrantReadWriteLock.ReadLock  readLock();
/*内部类同步器  基于aqs实现功能*/
abstract static class Sync extends AbstractQueuedSynchronizer{}
/*非公平sync*/
static final class NonfairSync extends Sync{}
/*公平sync*/
static final class FairSync extends Sync{}
/*读锁类*/
public static class ReadLock implements Lock, java.io.Serializable{}
/*写锁类*/
public static class WriteLock implements Lock, java.io.Serializable{}

类继承结构图

ReentrantReadWriteLock内部主要也是基于sync去实现的，无论是读锁还是写锁都是基于sync去操作的，内部都是操作的AbstractQueuedSynchronizer的state变量，那么如果用一个变量实现两个锁的状态呢，这个地方就需要牵涉到位操作了，ReentrantReadWriteLock将变量32位的state拆分为高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;
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

ReadLock与WriteLock

ReadLock与WriteLock都是其ReentrantReadWriteLock类的内部类，这两个锁都实现于lock接口，也都重写了相关的锁获取以及释放方法，那么接下来我们就两个锁的锁获取以及释放进行分析。

WriteLock锁获取以及锁释放原理

写锁的获取

        public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
        }
        protected final boolean tryAcquire(int acquires) {
            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)
                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;
        }

tryAcquire是写锁的获取锁的主要方法。首先获取到state变量值c，然后对变量值state进行c&((1 << 16) - 1)操作来获取到当前写锁的值，然后对判断state是否等于0。

如果等于0表示当前没有线程获取到锁，先查看当前队列是否有优先的等待队列（公平模式才会检查，非公平模式直接返回false），如果有直接返回true，没有则对state值直接进行cas替换操作，将c+acquires赋值给c，如果成功则设置exclusiveOwnerThread为当前线程，失败直接返回。
如果不等于0（表示已经有线程获取到了锁），首先判断w是否为0（也就是写锁是否被获取），如果写锁没有被其他线程获取或者获取写锁的线程不是当前线程则直接返回false 。其次判断写锁的值是不是超过范围，因为写锁与读锁的值被拆分为16位的数字，则该数字最大值为65535，如果超过范围直接抛出异常。上述条件都通过直接对c进行运算并赋值给c，这里大家可以关注到赋值并未做cas原子操作，是因为该线程已经获取到写锁了，变量操作是线程安全的所以不需要进行cas操作。

写锁的释放

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    protected final boolean tryRelease(int releases) {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

写锁的释放主要逻辑在tryRelease方法中，release只是调用了tryRelease方法，如果成功对其后继节点进行唤醒，如果后继节点存在的话。我们主要看下tryRelease方法逻辑，首先判断占有写锁的线程是否是当前线程，如果不是直接抛出异常IllegalMonitorStateException，如果是当前线程则对state进行计算，c=state-releases，如果c的低十六位数值为零，则说明写锁已经被释放，然后将ownerThread置为null，将c赋值给state返回c写锁的数值。这里在对state赋值的时候也没有涉及cas操作，原理是一样的因为写锁是独占锁，然后获取占有写锁的线程进行变量替换都是线程安全的。

ReadLock锁获取以及锁释放原理

读锁的获取

        public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
        }
        /*尝试获取共享锁*/
        protected final int tryAcquireShared(int unused) {
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)//1
                return -1;
            int r = sharedCount(c);//2
            if (!readerShouldBlock() &&
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {//3
                if (r == 0) {//4
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {//4
                    firstReaderHoldCount++;
                } else {//4
                    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);
        }
        
        /*以不间断模式进行获取共享锁*/
        private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

读锁的获取稍微复杂一些，先看下tryAcquireShared方法，tryAcquireShared是尝试获取锁，如果失败直接进入到doAcquireShared方法中。
tryAcquireShared方法：
1.首先判断写锁是否被占有，如果被占有查看占有线程是否是当前线程，如果不是直接返回false，如果是则进入读锁的获取，这段逻辑也表示写锁可重入读锁，如果后续写锁先释放那么也就达到了锁的降级功能。
2.获取state高十六位数值（也就是当前获取读锁的数量），r = state>>>16。
3.查看当前队列aqs中是否有优先的等待节点，如果有直接跳过进入fullTryAcquireShared，没有进行读锁数量判断，不能大于等于最大数值65535，如果大于进入fullTryAcquireShared，没有进行读锁数量+1并cas赋值，成功进行下一步，否则进入fullTryAcquireShared方法。
4.进入这一步表示读锁已经成功获取，接下来主要是对单个线程的读锁重入次数进行更新，先查看r值，如果r值为零表示当前没有线程获取读锁，则设置为firstReader为当前线程，并且将firstReaderHoldCount值设置为1，如果r不等于0（表示读锁已被其他线程获取），判断firstReader==current，如果相等进行firstReaderHoldCount++操作，如果不相等从ThreadLocalHoldCounter对象中获取HoldCounter，如果不存在创建HoldCounter放入ThreadLocalMap中，并对HoldCounter的value做++操作。

注意：tryAcquireShared方法结尾处会调用fullTryAcquireShared，fullTryAcquireShared这个方法其实也就是tryAcquireShared方法的自选模式，里面的逻辑没有太大的改变。

HoldCounter 用来储存单个线程获取读锁的重入数
cachedHoldCounter储存最后一个获取读锁的HoldCounter
firstReader表示第一个获取读锁的线程，只有一个线程获取读锁的时候提高性能，避免通过ThreadLocal去储存。
firstReaderHoldCount表示第一个获取读锁的线程的重入数，只有一个线程获取读锁的时候提高性能，避免通过ThreadLocal去储存。

doAcquireShared方法：
1.创建shared类型node排队节点。然后进入自旋代码块。
2.获取node的前置节点，如果前置节点等于head，进入tryAcquireShared方法，如果tryAcquireShared执行成功，则执行进行唤醒后继节点，执行完毕后返回。
3.判断是否需要阻塞当前线程，如果需要则直接阻塞。

读锁的释放

        protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            if (firstReader == current) {
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;
            }
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

读锁的释放主要逻辑在tryReleaseShared方法中，tryReleaseShared释放读锁的逻辑也相对较简单。
1.获取当前线程对象，判断是否等于firstReader，如果等于则直接对firstReader以及firstReaderHoldCount进行操作，如果不等于firstReader进入下一步。
2.从ThreadLocalMap中获取HoldCounter对象，判断HoldCounter对象的count是否小于等于1，如果小于1则直接移除ThreadLocalMap中的HoldCounter，然后对count进行自减操作。
3.最后对state变量进行操作，对aqs的state高十六位（读锁的数值）进行减一操作，然后进行cas将新的读锁数值赋值给state变量，然后返回结果。

总结

本文就ReentrantReadWriteLock的读锁与写锁的获取以及释放的源码进行了简单的分析，读写锁最核心的原理是将state值进行高16位以及低16位进行切割管理，以达到一个变量可同时实现读写锁的操作，其实ReentrantReadWriteLock内部还有很多其他的方法，感兴趣的小伙伴可以仔细阅读下，ReentrantReadWriteLock适合在读多写少的场景使用，在写多读少的场景下其实效率并不比ReentrantLock的效率高，并且需要特别注意的是读写锁可以进行锁降级，但是一定注意代码不要出现锁升级，锁升级会导致死锁。