一、ReentrantReadWriteLock简介

上一篇文章我们将讲到的ReentrantLock和Synchronized锁,都属于排他锁,也就是说只会有一个线程获取锁;而我们今天讲的ReentrantReadWriteLock(读写锁)是支持多个线程同时获取锁的在获取读锁时;但是在获取到写锁时,其它的写锁和读锁都会阻塞;其实可以看出读写锁,维护了一对锁,一个写锁,其实是个排他锁,一个读锁,是共享锁;通过分离读锁和写锁,使得并发性相比一般的排他锁有很大的提升;读写锁的性能比排他锁好,因为在大多数场景中读是多于写的;读写锁提供了,公平性的选择、重新进入(该锁支持重进入,以读写锁线程为例:读线程在获取读锁之后,能够再次获取读锁。而写线程在获取了写锁之后能够再次获取写锁,同时也可以获取读锁)和锁降级(遵循获取写锁、获取读锁在释放写锁的次序,写锁能够降级成为读锁)等特性。

二、ReentrantReadWriteLock基本成员
我们先来看一张ReentrantReadWriteLock类图
ReentrantReadWriteLock(可以重入的读写锁)源码浅析
Sync是一个内部类,继承AQS,主要实现AQS的一些方法。
ReentrantReadWriteLock(可以重入的读写锁)源码浅析
基本成员简介

     static final int SHARED_SHIFT   = 16;
        // 这个是读锁的原始累加值(也就是说每次获取读锁都是获取状态state,然后用state加它),是2^16
        // 举个例子,假设现在state为1,那么现在来获取读锁就是1+SHARED_UNIT
        static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
        // 读锁和写锁的最大数量,都是2^16 - 1
        static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
        // 写锁的掩码,其实就是2^16 - 1,这个数的二进制很特殊,16位全是1
        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

        /** Returns the number of shared holds represented in count  */
        // 读锁的数量
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
        /** Returns the number of exclusive holds represented in count  */
        // 写锁的数量
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

                // 记录每个线程获取读锁的数量
        // count是数量
        // tid是线程的唯一标识
        static final class HoldCounter {
            int count = 0;
            // Use id, not reference, to avoid garbage retention
            final long tid = getThreadId(Thread.currentThread());
        }

                // 继承ThreadLocal,主要用来存储HoldCounter
        static final class ThreadLocalHoldCounter
                extends ThreadLocal<java.util.concurrent.locks.ReentrantReadWriteLock.Sync.HoldCounter> {
            public java.util.concurrent.locks.ReentrantReadWriteLock.Sync.HoldCounter initialValue() {
                return new java.util.concurrent.locks.ReentrantReadWriteLock.Sync.HoldCounter();
            }
        }

                // 可以理解为最后一个获取读锁的线程(用于优化性能,不需要去ThreadLocal查找)
                 private transient HoldCounter cachedHoldCounter;

                 // 第一个获取读锁的线程和读锁的数量,作用是如果是第一个,不走ThreadLocal
                 private transient Thread firstReader = null;
                 private transient int firstReaderHoldCount;

解释下读写锁的状态计算,state一个数,怎么控制的读和写
先来看写锁,先来看写锁的掩码EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1,这个数是65535,二进制就是16个1,我们看见获取写锁的个数c & 65535(exclusiveCount这个方法,c代表就是state,锁的状态,不理解可以看看AQS对state的定义),但是由于二进制16位是1,所以只要c在0-65535这个范围,取&都还是c(由于这个掩码的特殊性),根据写锁的定义只能有一个线程获取写锁,写锁获取了就要阻塞其它线程获取读或者写,怎么判断了,其实只要判断c& 这个二进制是不是等于0就可以了,所以了写锁的范围其实就是0-65535,其实二进制的范围就是低16位(因为最大数量是MAX_COUNT = 2^16-1)。
再来分析下读锁,读锁我们主要关注下SHARED_UNIT就可以,获取锁其实是用c+SHARED_UNIT(c代表的就是sate),释放锁是用c-SHARED_UNIT,这个数是 65536(SHARED_UNIT 其实就是 2 ^ 16),我们每次获取读锁其实就是把SHARED_UNIT累加,其实我们可以把SHARED_UNIT的一次累加就当做一次读锁的获取,我们看下读锁的值得范围是0 - 负65536(负数和int的最大值有关,int正数的最大值是2147483647,在给它累加其实就会变为负数,最后最大其实就是高16位全是1,因为读锁的最大数量是MAX_COUNT = 2^16-1,所以其实读锁的范围可以看做是高16位),获取读锁的个数就是无符号右移16位(就是sharedCount方法),因为可能是负数。
ReentrantReadWriteLock(可以重入的读写锁)源码浅析
上面的图片其实就是一个读锁,一个写锁,这种情况只有在同一个线程才会发生,如果你能算出一个写锁和读锁,说明你基本理解了读写锁状态控制的运算方法。
ReadLock和WriteLock,内部类,继承Lock,提供一些锁的方法。
FairSync和NonfairSync,内部类,是继承Sync,主要实现公平和非公平的一些方法

三、ReentrantReadWriteLock基本方法
1)、构造方法

// 无参,默认非公平
public ReentrantReadWriteLock() {
        this(false);
    }
        // 有参
        public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

2)、WriteLock:写锁一些方法,如下图:
ReentrantReadWriteLock(可以重入的读写锁)源码浅析

①、获取锁lock方法,我们可以看出调用的是sync.acquire方法,由于sync继承自AQS所以调用的其实是AQS的acquire,但是AQS的tryAcquire需要子类自己实现,所以我们看看tryAcquire(可以看出是个独占方法,也符合写锁的定义,只会有一个线程获取)。

public void lock() {
            sync.acquire(1);
        }

子类sync的tryAcquire

// 写锁的状态控制(state)
        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();
            // 获取写锁的状态,c & (2的16次方-1)
            // 2的16次方-1 其实就是65535,变成二进制就是16个1
            int w = exclusiveCount(c);
            // c不等于0,证明有线程获取锁了,不管是读锁或者写锁
            if (c != 0) {
                // (Note: if c != 0 and w == 0 then shared count != 0)
                // w == 0,说明有读锁了,w!= 0证明有写锁
                // current != getExclusiveOwnerThread()说明有写锁了,不是自己
                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;
            }
            // 走到这一步,证明还没有线程获取锁
            // writerShouldBlock 现在公平还是非公平,由FairSync和NonfairSync实现这个方法
            if (writerShouldBlock() ||
                    // cas设置所得状态
                    !compareAndSetState(c, c + acquires))
                //失败或者公平锁在我的前面有排队节点
                return false;
            // 设置拥有锁的线程
            setExclusiveOwnerThread(current);
            return true;
        }

在上面的写锁获取锁时我们需要注意下writerShouldBlock这个方法,它是实现公平和非公平的关键,它的公平和非公平的方法实现不同,公平是需要确认自己前面是否有排队节点,非公平直接返回false,具体查看这个方法。
②、写锁释放锁:unlock方法,它是其实也是调用的也是调用AQS的release方法,我们直接看子类的实现吧。

public void unlock() {
            sync.release(1);
        }

子类sync的tryRelease方法

protected final boolean tryRelease(int releases) {
            // 判断是否获取锁的是这个线程
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            // 释放锁,修改state
            int nextc = getState() - releases;
            // 判断写锁是否完全释放
            boolean free = exclusiveCount(nextc) == 0;
            // 完全释放,修改锁的拥有者为null
            if (free)
                setExclusiveOwnerThread(null);
            // cas状态
            setState(nextc);
            return free;
        }

③、我们发现WriteLock里面还有一些获取锁的方法,lockInterruptibly响应中断,tryLock(long timeout, TimeUnit unit)支持中断并且带超时时间,其实都是调用了AQS里面的这些方法,然后获取锁这部分的实现都是调用的子类sync的tryAcquire方法。
3)、ReadLock:读锁的一些方法,如下图
ReentrantReadWriteLock(可以重入的读写锁)源码浅析
①、获取锁lock方法,调用过程和写锁一样,先走AQS,不过这一次调用的是共享锁的方法acquireShared,然后AQS在调用子类sync的实现方法。

public void lock() {
            sync.acquireShared(1);
        }

sync的tryAcquireShared

protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. If write lock held by another thread, fail.
             * 2. Otherwise, this thread is eligible for
             *    lock wrt state, so ask if it should block
             *    because of queue policy. If not, try
             *    to grant by CASing state and updating count.
             *    Note that step does not check for reentrant
             *    acquires, which is postponed to full version
             *    to avoid having to check hold count in
             *    the more typical non-reentrant case.
             * 3. If step 2 fails either because thread
             *    apparently not eligible or CAS fails or count
             *    saturated, chain to version with full retry loop.
             */
            // 获取当前线程
            Thread current = Thread.currentThread();
            // 获取当前锁状态
            int c = getState();
            // exclusiveCount(c) != 0 有线程获取了写锁
            // 并且这个获取写锁的线程不是自己
            if (exclusiveCount(c) != 0 &&
                    getExclusiveOwnerThread() != current)
                return -1;
             // 现在只会有三种清理
            // 1、还没有任何线程获取锁,不管是读锁还是写锁
            // 2、有线程获取到了读锁
            // 3、获取写锁的线程时自己
            int r = sharedCount(c);
            //  readerShouldBlock 由FairSync和NonfairSync实现
            // FairSync 判断是否前面有排队节点
            // NonfairSync排队节点是否有写节点
            if (!readerShouldBlock() &&
                    r < MAX_COUNT &&
                    compareAndSetState(c, c + SHARED_UNIT)) {
                // r == 0证明还没有获取到锁
                if (r == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                    // 重入锁
                } else if (firstReader == current) {
                    firstReaderHoldCount++;
                } else {
                    // 获取最后一个获取锁的HoldCounter
                    java.util.concurrent.locks.ReentrantReadWriteLock.Sync.HoldCounter rh = cachedHoldCounter;
                    // 最后一个HoldCounter是空或者不是本线程,就设置一个
                    if (rh == null || rh.tid != getThreadId(current))
                        // 其实这一步做了两件事情,其实是先set了一个HoldCounter,然后在get之后设置给rh
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0) // 理解不了什么时候会是0
                        readHolds.set(rh);
                    rh.count++;
                }
                return 1;
            }
            // 执行fullTryAcquireShared方法有几种情况了
            // 1.获取锁的下一个节点还是写锁,需要等待
            // 2.到达获取锁的最大数量
            // 3.可能存在多线程进程来设置读锁,cas失败了
            return fullTryAcquireShared(current);
        }

                final int fullTryAcquireShared(Thread current) {
            /*
             * This code is in part redundant with that in
             * tryAcquireShared but is simpler overall by not
             * complicating tryAcquireShared with interactions between
             * retries and lazily reading hold counts.
             */
            java.util.concurrent.locks.ReentrantReadWriteLock.Sync.HoldCounter rh = null;
            for (;;) { // 自旋获取锁
                int c = getState(); // 获取锁状态
                if (exclusiveCount(c) != 0) { // 判断有没有写锁,不等于0证明有写锁
                    if (getExclusiveOwnerThread() != current) // 写锁不是自己
                        return -1;  // 返回
                        // 写锁时自己,其实就可以获取,其实就是锁降级(可以看做是一种特殊的重入锁)
                    // else we hold the exclusive lock; blocking here
                    // would cause deadlock.

                    // 到下面这个else if证明没有写锁
                    //  readerShouldBlock 由FairSync和NonfairSync实现公平和非公平原则
                    // FairSync 判断是否前面有排队节点
                    // NonfairSync排队节点是否有写节点
                } else if (readerShouldBlock()) { // 到这一步证明了,是公平锁或者非公平锁的头结点.next是写锁,
                                                    // 此线程需要进入同步队列了,下面就是判断这个线程有没有获取过锁
                    // Make sure we're not acquiring read lock reentrantly
                    // 第一个获取锁的是当前线程,证明可以重入
                    if (firstReader == current) {
                        // assert firstReaderHoldCount > 0;
                    } else {
                        // 进去这里说明,firstReader不是当前线程,那就说明获取读锁的不止一个了,因为firstReader不可能为null
                        // 获取最后一个获取读锁的HoldCounter
                        if (rh == null) { // rh == null 只会是第一次循环
                            rh = cachedHoldCounter; // 获取缓存的HoldCounter
                            if (rh == null || rh.tid != getThreadId(current)) {
                                // 从 ThreadLocal 中取出计数器,如果没有就会重新创建并设置
                                rh = readHolds.get();
                                if (rh.count == 0) // 那就证明没有获取到读读锁
                                    readHolds.remove(); // 删除这个
                            }
                        }
                        if (rh.count == 0) // 这个是上面刚刚创建的证明获取锁失败了,需要进入队列
                            return -1;
                    }
                }
                // 获取读锁的数量==MAX_COUNT,抛异常
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");

                // 使用cas设置读锁的状态,下面逻辑和tryAcquireShared的逻辑一样
                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;
                }
            }
        }

在读锁获取锁时需要注意下readerShouldBlock这个方法,和写锁类似,这个方法也是主要实现公平与非公平的关键,非公平锁(NonfairSync)时需要注意,如果获取读锁时,需要执行apparentlyFirstQueuedIsExclusive这个方法,判断队列head的next是否是写锁(是写锁,让这个写锁先来,避免写锁饥饿,就是避免写线程获取不到锁,所以写有很高的优先权),则自己获取读锁就需要排队,公平锁(FairSync)实现则还是需要判断队列里面是否有节点在排队。
②、释放锁unlock,调用AQS的releaseShared方法,我们主要关注子类实现

 public void unlock() {
            sync.releaseShared(1);
        }

子类sync的tryReleaseShared方法

protected final boolean tryReleaseShared(int unused) {
            // 获取当前线程
            Thread current = Thread.currentThread();
            // 如果第一个读锁拥有者是当前线程
            if (firstReader == current) {
                // assert firstReaderHoldCount > 0;
                // 读锁的数量为1,没有重入
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    // 重入了,修改数量
                    firstReaderHoldCount--;
                // 读锁已经不是一个了
            } else {
                // 获取最后一个缓存
                java.util.concurrent.locks.ReentrantReadWriteLock.Sync.HoldCounter rh = cachedHoldCounter;
                 // 获取缓存HoldCounter
                if (rh == null || rh.tid != getThreadId(current))
                    // 不是就获取
                    rh = readHolds.get();
                // 获取读锁线程的数量
                int count = rh.count;
                // 如果小于等于1
                if (count <= 1) {
                    // 删除这个线程的HoldCounter
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                // 读锁数量递减
                --rh.count;
            }
            for (;;) {
                // 获取状态stase
                int c = getState();
                                    // 读锁状态减1(其实就是减SHARED_UNIT)
                int nextc = c - SHARED_UNIT;
                // cas设置线程状态
                if (compareAndSetState(c, nextc))
                    // Releasing the read lock has no effect on readers,
                    // but it may allow waiting writers to proceed if
                    // both read and write locks are now free.
                    // 为什么nextc == 0才会返回true了
                    // nextc == 0代表了什么了,没有读锁了
                    // 返回true,就代表可以去唤醒下一个线程了,但是队列的线程是写线程或者线程了,不确定
                    // 但是这个对读线程是没有影响的,但是对写锁是有影响的,我们想象一下什么情况下才会下个节点会是写锁获取的线程了
                    // 其实就是已经有线程获取了写锁,因为有线程获取了写锁,所以可能发生锁降级,写锁降级为读锁
                    // 为了保护锁降级的语义,所以必须保护读锁,直到没有读锁了才会去唤醒后面可能的写锁,也就是返回true
                    return nextc == 0;
            }
        }

③、lockInterruptibly和tryLock(long timeout, TimeUnit unit)和写锁的这些方法作用一样。
四、总结

ReentrantReadWriteLock读写锁,要想学习好这个类,就必须了解什么是读锁,什么是写锁,怎么区别读锁和写锁,因为我们都知道锁都是通过AQS的state来控制的,但是现在是两个锁,所以理解ReentrantReadWriteLock对state拆分的运算很重要,也就是二进制的低16位是写锁,高16位是读锁,也不得不说大神设计让人叹为观止啊;还有就是理解读写锁的一些特性,重入指的就是同一个线程获取锁之后,再次调用lock方法不会被阻塞,但是注意调用几次lock,就要调用几次unlock,因为我们通过源码得知重入其实就是对state的累加,还有就是锁降级,我个人更愿意理解为特殊的重入,锁降级就是一个线程先获得写锁,然后这个线程再去获取读锁,这样不会阻塞,然后写锁其实就降级为了读锁,然后在释放写锁,最后释放读锁,作者为什么这么设计了,书上说的,锁降级主要是为了保证数据的可见性,如果当前线程不获取读锁而是直接释放写锁,假设此刻另一个线程(记作线程T)获取了写锁并修改了数据,那么当前线程无法感知线程T的数据更新,如果当前线程获取读锁,即遵循锁降级的步骤,则线程T,就会阻塞,直到当前线程使用数据并释放读锁之后,线程T才会获得写锁并更新数据。个人理解这个锁降级其实是一种特殊的锁的优化策略,在我们需要在边写边读的这种业务场景中,保证数据可见性的同时(不让其他线程获取写锁),提升本线程读锁性能,因为不需要和写锁或者其他读锁(公平锁)去竞争获取锁,而是直接降级为读锁。
参考 《Java 并发编程的艺术》