ReentrantReadWriteLock

ReentrantReadWriteLock.png 456af507-f0aa-4b02-afbd-1d137c239245.png

WriteLock

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

tryAcquire

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)
        // c不等0，w等于0，说明现在有人持有读锁，所以写锁拿不到
        // 就算有人持有写锁，如果是别人的话，当然也不能拿到写锁
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        // 到这里，说明当前线程持有锁
        // 重入写锁计数累加不能超过阈值，否则报错
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
        // 设置state的重入计数
        setState(c + acquires);
        return true;
    }
    // 如果state等于0，说明现在还没有人持有任何锁
    // 看是否按照公平原则来依次获取写锁，如果不是最早的waiter，那么会return
    // 如果非公平模式，那么会尝试设置写锁计数，成功的话，绑定当前线程
    // 否则返回
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}

tryRelease

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;
}

tryWriteLock

final boolean tryWriteLock() {
    Thread current = Thread.currentThread();
    int c = getState();
    if (c != 0) {
        int w = exclusiveCount(c);
        // c不等0，w等于0，说明现在有人持有读锁，所以写锁拿不到
        // 就算有人持有写锁，如果是别人的话，当然也不能拿到写锁        
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        // 是否写锁已经满了
        if (w == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
    }
    // 尝试独占锁数量加一，成功的线程才能独占并绑定
    if (!compareAndSetState(c, c + 1))
        return false;
    // 设置当前持有人
    setExclusiveOwnerThread(current);
    return true;
}

ReadLock

tryReadLock

final boolean tryReadLock() {
    Thread current = Thread.currentThread();
    // 自旋
    for (;;) {
        int c = getState();
        // 如果有人持有写锁，且不是自己，那么读锁获取失败，返回false
        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)) {
            // 如果之前的计数为0，那么这个线程应该是第一个持有人，设置firstreader和HoldCount
            if (r == 0) {
                firstReader = current;
                firstReaderHoldCount = 1;
            // 直接firstReaderHoldCount累加
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
                // cachedHoldCounter可以理解为最近一次读锁的持有人及计数
                HoldCounter rh = cachedHoldCounter;
                // 如果rh为空或持有人不是当前线程，那么去获取当前线程的HoldCounter
                if (rh == null || rh.tid != getThreadId(current))
                    // 如果当前线程没有的话，会去init一个
                    // 或拿到持有人的HoldCounter
                    cachedHoldCounter = rh = readHolds.get();
                else if (rh.count == 0)
                    readHolds.set(rh);
                // 计数累加
                rh.count++;
            }
            // 成功拿到读锁，结束自旋
            return true;
        }
    }
}

tryAcquireShared

protected final int tryAcquireShared(int unused) {
    Thread current = Thread.currentThread();
    int c = getState();
    // 如果当前状态时被其他线程独占，返回-1
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;
    // 拿到当前共享锁的数量
    int r = sharedCount(c);
    // readerShouldBlock返回false
    // 1. 下一个等待的线程必须是自己 （公平锁）
    // 2. 只要下一个等待的不是写锁，谁来都可以 （非公平锁）
    // 总之是可以拿读锁的状态
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        // CAS只要修改成功，就拿到锁
        compareAndSetState(c, c + SHARED_UNIT)) {
        // 如果当前还没有人共享，设置firstReader以及firstReaderHoldCount
        if (r == 0) {
            firstReader = current;
            firstReaderHoldCount = 1;
        // 如果firstReader已经是当前线程，只需要累加firstReaderHoldCount，记录重入数
        } else if (firstReader == current) {
            firstReaderHoldCount++;
        } else {
            HoldCounter rh = cachedHoldCounter;
            // 如果rh为空或持有人不是当前线程，那么去获取当前线程的HoldCounter
            if (rh == null || rh.tid != getThreadId(current))
                // 如果当前线程没有的话，会去init一个
                // 或拿到持有人的HoldCounter
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0)
                readHolds.set(rh);
            // 自增当前线程的共享锁数目
            rh.count++;
        }
        // 成功拿到锁，返回
        return 1;
    }
    // 如果上面的步骤还没有拿到锁，那么进入自旋模式
    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.
     */
    HoldCounter rh = null;
    // 自旋
    for (;;) {
        int c = getState();
        // 如果当前有其他人持有写锁，那么返回-1，进入等待队列
        // 那么有种情况是，正好是当前线程持有写锁，那么直接去下面执行锁降级
        if (exclusiveCount(c) != 0) {
            if (getExclusiveOwnerThread() != current)
                return -1;
            // else we hold the exclusive lock; blocking here
            // would cause deadlock.
        // 进到这里，说明当前没有人持有写锁，但是因为下面的原因导致获取读锁应该等待
        // 1. 下个等待的线程不是自己 （公平锁）
        // 2. 下一个等待的线程需要的写锁，非公平模式下写锁优先 （非公平锁）
        } else if (readerShouldBlock()) {
            // Make sure we're not acquiring read lock reentrantly
            // 应该是个优化，如果发现读锁列表中跟firstReader匹配
            // 说明是个重入读锁，直接去下面去累加重入计数
            if (firstReader == current) {
                // assert firstReaderHoldCount > 0;
            } else {
                if (rh == null) {
                    rh = cachedHoldCounter;                    
                    if (rh == null || rh.tid != getThreadId(current)) {
                        rh = readHolds.get();
                        if (rh.count == 0)
                            readHolds.remove();
                    }
                }
                // 到这里没拿到读锁，那么也进入等待队列
                if (rh.count == 0)
                    return -1;
            }
        }
        if (sharedCount(c) == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // CAS获取读锁，并做记录
        if (compareAndSetState(c, c + SHARED_UNIT)) {
            // 如果读锁为0，那么记录下firstReader和HoldCount
            if (sharedCount(c) == 0) {
                firstReader = current;
                firstReaderHoldCount = 1;
            // 如果firstReader已经是当前线程，只需要累加firstReaderHoldCount，记录重入数
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
                // 设置当前线程为cachedHoldCounter
                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;
        }
    }
}

tryReleaseShared

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 (;;) {
        int c = getState();
        int nextc = c - SHARED_UNIT;
        // 总读锁计数要减一
        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.
            // 最后要比较是否总读锁数是否归零，好让写锁切入
            return nextc == 0;
    }
}

FairSync

writerShouldBlock&readerShouldBlock

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    // true. 
    //    没有等待线程
    //    有，但不是当前线程
    // false
    //    有，且是当前线程
    // 而公平原则下，不像非公平那样写锁优先的逻辑，只是看队列的顺序，轮到谁了，谁来拿锁。
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

NonfairSync

writerShouldBlock

final boolean writerShouldBlock() {
    // 非公平下写锁是可以插队的，只要你够幸运
    return false; // writers can always barge
}

readerShouldBlock

final boolean apparentlyFirstQueuedIsExclusive() {
    Node h, s;
    // true
    //    有等待列表，且最早的等待的线程不是为了读锁，且thread不为空
    //    换句话说，读锁是否需要等待得看后面等待的是不是写锁，如果是，写锁优先。
    return (h = head) != null &&
        (s = h.next)  != null &&
        !s.isShared()         &&
        s.thread != null;
}