Java 讀寫鎖 ReadWriteLock 原理與應用場景詳解

public interface ReadWriteLock {    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.     */
    Lock readLock();    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.     */
    Lock writeLock();
}

/** 內部提供的讀鎖 */
    private final ReentrantReadWriteLock.ReadLock readerLock;    /** 內部提供的寫鎖 */
    private final ReentrantReadWriteLock.WriteLock writerLock;    /** AQS來實現的同步器 */
    final Sync sync;    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * 預設建立非公平的讀寫鎖     */
    public ReentrantReadWriteLock() {        this(false);
    }    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

abstract static class Sync extends AbstractQueuedSynchronizer {    // 版本序列號
    private static final long serialVersionUID = 6317671515068378041L;        
    // 高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;    // 本地執行緒計數器
    private transient ThreadLocalHoldCounter readHolds;    // 快取的計數器
    private transient HoldCounter cachedHoldCounter;    // 第一個讀執行緒
    private transient Thread firstReader = null;    // 第一個讀執行緒的計數
    private transient int firstReaderHoldCount;
}

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();            //獲取獨佔鎖(寫鎖)的被獲取的數量
            int w = exclusiveCount(c);            if (c != 0) {                // (Note: if c != 0 and w == 0 then shared count != 0)                //1.如果同步狀態不為0，且寫狀態為0,則表示當前同步狀態被讀鎖獲取                //2.或者當前擁有寫鎖的執行緒不是當前執行緒
                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;
        }

protected final int tryAcquireShared(int unused) {    for(;;) {        int c = getState();        int nextc = c + (1<<16);        if(nextc < c) {           throw new Error("Maxumum lock count exceeded");
        }        if(exclusiveCount(c)!=0 && owner != Thread.currentThread())           return -1;        if(compareAndSetState(c,nextc))           return 1;
    }
}