ReentrantReadWriteLock （读写锁）源码分析

关于AbstractQueuedSynchronizer中的独占锁，请参考ReentrantLock（http://www.cnblogs.com/bjorney/p/8040085.html）

1. ReentrantReadWriteLock

// ReentrantReadWriteLock本身不提供加锁服务，只负责提供读锁和写锁
public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    private final ReentrantReadWriteLock.ReadLock readerLock;
    private final ReentrantReadWriteLock.WriteLock writerLock;
    final Sync sync;

    public ReentrantReadWriteLock() {
        this(false);
    }

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

    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; } // 写锁
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; } // 读锁

    // 总的读锁计数
    public int getReadLockCount() {
        return sync.getReadLockCount();
    }

    // 当前线程的写锁计数（当前线程必须占有锁）
    public int getWriteHoldCount() {
        return sync.getWriteHoldCount();
    }

    // 当前线程的读锁计数
    public int getReadHoldCount() {
        return sync.getReadHoldCount();
    }

    // 获取所有在SyncQueue中排队的写线程
    protected Collection<Thread> getQueuedWriterThreads() {
        return sync.getExclusiveQueuedThreads();
    }

    // 获取所有在SyncQueue中排队的读线程
    protected Collection<Thread> getQueuedReaderThreads() {
        return sync.getSharedQueuedThreads();
    }

    ... ...

    static final long getThreadId(Thread thread) {
        return UNSAFE.getLongVolatile(thread, TID_OFFSET); // tid在Thread类中非volatile
    }

    private static final sun.misc.Unsafe UNSAFE;
    private static final long TID_OFFSET;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            TID_OFFSET = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("tid"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

}

2. ReentrantReadWriteLock.ReadLock

public static class ReadLock implements Lock, java.io.Serializable {
    private final Sync sync;

    protected ReadLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }

    public void lock() { // 加读锁
        sync.acquireShared(1);
    }

    public void lockInterruptibly() throws InterruptedException { // 加读锁（可被中断）
        sync.acquireSharedInterruptibly(1);
    }

    public boolean tryLock() { // 尝试加读锁
        return sync.tryReadLock();
    }

    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { // 加读锁（在timeOut内等锁）
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    public void unlock() { // 释放读锁
        sync.releaseShared(1);
    }

    ... ...
}

3. ReentrantReadWriteLock.WriteLock

public static class WriteLock implements Lock, java.io.Serializable {
    private final Sync sync;

    protected WriteLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }

    public void lock() { // 加写锁
        sync.acquire(1);
    }

    public void lockInterruptibly() throws InterruptedException { // 加写锁（可被中断）
        sync.acquireInterruptibly(1);
    }

    public boolean tryLock( ) { // 尝试加写锁
        return sync.tryWriteLock();
    }

    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { // 加写锁（在timeOut内等锁）
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    public void unlock() { // 释放写锁
        sync.release(1);
    }

    ... ...
}

4. ReentrantReadWriteLock.Sync

abstract static class Sync extends AbstractQueuedSynchronizer {
    static final int SHARED_SHIFT   = 16; // state高16位为读锁计数，state低16位为写锁计数
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT); // 读锁计数 + 1
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1; // 读（写）锁计数 <= 2^16 - 1
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1; // 写锁计数 = state & (2^16 - 1)

    Sync() {
        readHolds = new ThreadLocalHoldCounter();
        setState(getState());
    }

    // return 锁状态（锁计数）
    final int getCount() { return getState(); }

    // 总的读锁计数
    final int getReadLockCount() {
        return sharedCount(getState());
    }
    static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }

    // 当前线程的写锁计数（当前线程必须占有锁）
    final int getWriteHoldCount() {
        return isHeldExclusively() ? exclusiveCount(getState()) : 0;
    }
    static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

    // 当前线程的读锁计数
    final int getReadHoldCount() {
        if (getReadLockCount() == 0)
            return 0;

        Thread current = Thread.currentThread();
        if (firstReader == current)
            return firstReaderHoldCount;

        HoldCounter rh = cachedHoldCounter;
        if (rh != null && rh.tid == getThreadId(current))
            return rh.count;

        int count = readHolds.get().count;
        if (count == 0) readHolds.remove();
        return count;
    }

    private transient ThreadLocalHoldCounter readHolds; // 当前线程的读锁计数
    private transient HoldCounter cachedHoldCounter; // 缓存的线程读锁计数
    private transient Thread firstReader = null; // 首个读线程
    private transient int firstReaderHoldCount; // 首个读线程的读锁计数

    static final class HoldCounter {
        int count = 0;
        // tid在Thread类中非volatile
        // Thread.getId -> UNSAFE.getLongVolatile(Thread.currentThread(), Thread.class.getDeclaredField("tid"))
        final long tid = getThreadId(Thread.currentThread());
    }

    static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
        public HoldCounter initialValue() {
            return new HoldCounter(); // {0, currentThreadId}
        }
    }

    // 尝试取写锁
    protected final boolean tryAcquire(int acquires) {
        Thread current = Thread.currentThread();
        int c = getState();                         /*记录state*/
        int w = exclusiveCount(c); // 写锁计数w
        if (c != 0) {// 读线程未释放锁 || 当前线程不是锁的独占者
            if (w == 0 || current != getExclusiveOwnerThread())
                return false; // 取锁失败
            // 当前线程已占有锁（Reentrant）
            if (w + exclusiveCount(acquires) > MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            setState(c + acquires); // 更新锁状态，写锁计数++
            return true; // 成功取锁（已占有锁）
        }
        // state == 0
        if (writerShouldBlock() || // false（NonfairSync）|| hasQueuedPredecessors（FairSync）
            !compareAndSetState(c, c + acquires))   /*CAS设置state += acquires*/
            // CAS(state)失败
            return false; // 取锁失败
        // CAS(state)成功
        setExclusiveOwnerThread(current); // 设置当前线程为锁的独占者
        return true; // 成功取锁
    }

    // 尝试抢写锁，不进行writerShouldBlock判断
    final boolean tryWriteLock() {
        Thread current = Thread.currentThread();
        int c = getState();
        if (c != 0) {
            int w = exclusiveCount(c);  // 写锁计数w
            // 读线程未释放锁 || 当前线程不是锁的独占者
            if (w == 0 || current != getExclusiveOwnerThread())
                return false;
            // 当前线程已占有锁（Reentrant）
            if (w == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
        }
        if (!compareAndSetState(c, c + 1)) // CAS设置state += 1
            // CAS(state)失败
            return false; // 抢锁失败
        // CAS(state)成功
        setExclusiveOwnerThread(current);
        return true; // 抢锁成功
    }

    // 尝试取读锁
    protected final int tryAcquireShared(int unused) {
        Thread current = Thread.currentThread();
        int c = getState();                             /*记录state*/
        // 写线程未释放锁 && 未释放锁的写线程非当前线程（读写线程可为同一线程）
        if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current)
            return -1; // 取锁失败
        int r = sharedCount(c); // 读锁计数r
        if (!readerShouldBlock() && // apparentlyFirstQueuedIsExclusive（NonfairSync）|| hasQueuedPredecessors（FairSync）
            r < MAX_COUNT && // r未超过阈值
            compareAndSetState(c, c + SHARED_UNIT)) {   /*CAS设置state += SHARED_UNIT*/ // 读锁计数++
            // CAS(state)成功
            if (r == 0) { // 首个读线程
                firstReader = current;
                firstReaderHoldCount = 1;
            } else if (firstReader == current) { // 当前线程为首个读线程
                firstReaderHoldCount++;
            } else { // 当前线程非首个读线程
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current)) // 缓存为空 || 缓存的不是当前线程的读锁计数
                    cachedHoldCounter = rh = readHolds.get();
                else if (rh.count == 0) // 缓存的是当前线程的读锁计数，而当前线程的读锁计数在上次release时被删除
                    readHolds.set(rh);
                rh.count++;
            }
            return 1; // 成功取锁
        }
        // CAS(state)失败
        return fullTryAcquireShared(current);
    }

    // 不断尝试取读锁，直到取锁失败（写线程占有锁 || 当前线程的读锁计数为0） || 成功取锁
    final int fullTryAcquireShared(Thread current) {
        HoldCounter rh = null;
        for (;;) {
            // 当前线程的读锁计数不为0 && CAS(state)失败将回到此处
            int c = getState();                             /*记录state*/
            if (exclusiveCount(c) != 0) { // 写线程未释放锁
                if (getExclusiveOwnerThread() != current) // 当前线程不是锁的独占者
                    return -1;// 取锁失败
            } else if (readerShouldBlock()) {
                if (firstReader == current) {
                } else {
                    if (rh == null) {
                        rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current)) {
                            rh = readHolds.get();
                            if (rh.count == 0) // 当前线程的读锁计数为0
                                readHolds.remove(); // 在线程局部变量中删除当前线程的读锁计数
                        }
                    }
                    if (rh.count == 0) // 当前线程的读锁计数为0
                        return -1; // 应排队取锁
                    // 继续尝试取锁
                }
            }
            if (sharedCount(c) == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            if (compareAndSetState(c, c + SHARED_UNIT)) {   /*CAS设置state += SHARED_UNIT*/
                // CAS(state)成功
                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; // 成功取锁
            }
            // CAS(state)失败
        }
    }

    // 尝试抢读锁，不进行readerShouldBlock判断
    final boolean tryReadLock() {
        Thread current = Thread.currentThread();
        for (;;) {
            // CAS(state)失败将回到此处
            int c = getState();                             /*记录state*/
            // 写线程未释放锁 && 未释放锁的写线程非当前线程（读写线程可为同一线程）
            if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current)
                return false; // 抢锁失败
            int r = sharedCount(c);
            if (r == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            if (compareAndSetState(c, c + SHARED_UNIT)) {   /*CAS设置state += SHARED_UNIT*/
                // CAS(state)成功
                if (r == 0) { // 首个读线程
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) { // 当前线程为首个读线程
                    firstReaderHoldCount++;
                } else { // 当前线程非首个读线程
                    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 true; // 成功抢锁
            }
            // CAS(state)失败
        }
    }

    // 尝试释放写锁
    protected final boolean tryRelease(int releases) {
        if (!isHeldExclusively()) // 当前线程未占有锁
            throw new IllegalMonitorStateException();
        int nextc = getState() - releases;
        boolean free = exclusiveCount(nextc) == 0; // 写锁计数是否为0
        if (free) // 可释放锁
            setExclusiveOwnerThread(null); // 锁的独占者置空
        setState(nextc); // 更新锁状态
        return free;
    }

    // 尝试释放读锁
    protected final boolean tryReleaseShared(int unused) {
        Thread current = Thread.currentThread();
        if (firstReader == current) { // 当前线程为首个读线程
            // assert firstReaderHoldCount > 0;
            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 (;;) {
            // CAS(state)失败将回到此处
            int c = getState();                 /*记录state*/
            int nextc = c - SHARED_UNIT; // 读锁计数--
            if (compareAndSetState(c, nextc))   /*CAS设置state = nextc*/
                // CAS(state)成功
                return nextc == 0;
            // CAS(state)失败
        }
    }

    ... ...
}

static final class NonfairSync extends Sync {
    final boolean writerShouldBlock() { // 写线程永远可以抢锁
        return false;
    }
    final boolean readerShouldBlock() { // SyncQueue排队的第一个节点（head.next）为写节点占锁时必须排队
        return apparentlyFirstQueuedIsExclusive();
    }
}

static final class FairSync extends Sync {
    final boolean writerShouldBlock() { // SyncQueue中下个待唤醒节点不是当前线程时必须排队
        return hasQueuedPredecessors();
    }
    final boolean readerShouldBlock() { // SyncQueue中下个待唤醒节点不是当前线程时必须排队
        return hasQueuedPredecessors();
    }
}

5. AbstractQueuedSynchronizer

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {

    // 尝试取读锁，取锁失败则排队等锁
    public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0) // 尝试取锁失败
            doAcquireShared(arg); // 排队等锁
    }

    // 排队等读锁
    private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED); // 在SyncQueue尾部添加读节点（共享锁：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) { // tryAcquireShared成功
                        setHeadAndPropagate(node, r); // 置SyncQueue头结点为node，唤醒node后置位读节点
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    // 置SyncQueue头结点为node，唤醒node后置位读节点
    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head;
        setHead(node); // 置SyncQueue头结点为node
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next; // s为node后置节点
            if (s == null || s.isShared()) // s为空 || s为读节点
                doReleaseShared(); // 唤醒s：s若取消排队（被中断 || 超时），则可能唤醒写节点
        }
    }

    // 尝试释放读锁，成功释放锁时unpark successor
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) { // 成功释放锁
            doReleaseShared(); // 唤醒后置位节点
            return true;
        }
        // 未释放锁
        return false;
    }

    // unpark successor
    private void doReleaseShared() {
        for (;;) {
            // CAS(head.waitStatus)失败将回到此处
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) { // head后置位节点等待被唤醒
                    // 可能其它读线程正在同步设置head.waitStatus
                    // A线程执行完毕后tryReleaseShared，锁被释放，B线程抢锁成功（未参与排队）
                    // B线程执行完毕后tryReleaseShared，A、B同步doReleaseShared
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) // CAS设置head.waitStatus = 0
                        // CAS(head.waitStatus)失败
                        continue;
                    // CAS(head.waitStatus)成功
                    unparkSuccessor(h);
                    // 若此时是读线程在setHeadAndPropagate中释放后置位读节点，则可能唤醒写节点：
                    // 被唤醒的写节点若tryAcquire失败，则将在shouldParkAfterFailedAcquire中重置head.waitStatus = Node.SIGNAL
                }
                // ws == 0：head后置位节点为空 || head后置节点已被其它线程唤醒
                // 可能其它读线程正在同步设置head.waitStatus
                // A线程执行完毕后tryReleaseShared，锁被释放，B线程抢锁失败（未参与排队）
                // B线程在SyncQueue末尾添加新节点，并在shouldParkAfterFailedAcquire中同步设置head.waitStatus = Node.SIGNAL
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) // CAS设置head.waitStatus = Node.PROPAGATE
                    // CAS(head.waitStatus)失败
                    continue;
                // CAS(head.waitStatus)成功
            }
            if (h == head) // 后置位读节点被唤醒并成为head后，将继续唤醒后置读节点
                break;
        }
    }

    // 尝试取读锁，取锁失败则排队等锁（可被中断）
    public final void acquireSharedInterruptibly(int arg) throws InterruptedException;
    // 排队等读锁（可被中断）
    private void doAcquireSharedInterruptibly(int arg) throws InterruptedException;

    // 尝试取读锁，取锁失败则排队等锁（nanosTimeout时间内)
    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException;
    // 排队等读锁（nanosTimeout时间内)
    private boolean doAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException;

    // SyncQueue排队的第一个节点（head.next）为写节点
    final boolean apparentlyFirstQueuedIsExclusive() {
        Node h, s;
        return (h = head) != null && // head不为空
            (s = h.next)  != null && // head存在后置节点
            !s.isShared()         && // head.next以独占方式取锁（为写节点）
            s.thread != null; // head.next未取消排队
    }

    // 获取所有在SyncQueue中排队的写线程
    public final Collection<Thread> getExclusiveQueuedThreads();

    // 获取所有在SyncQueue中排队的读线程
    public final Collection<Thread> getSharedQueuedThreads();

    ... ...
}