ReentrantReadWriteLock源码

@SuppressWarnings("restriction")
public class ReentrantReadWriteLock1 implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    private final ReentrantReadWriteLock1.ReadLock readerLock;
    private final ReentrantReadWriteLock1.WriteLock writerLock;
    final Sync sync;

    public ReentrantReadWriteLock1() {
        this(false);
    }

    public ReentrantReadWriteLock1(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);//写锁和读锁，公用同一个Sync，也就是同一个AQS队列，
        writerLock = new WriteLock(this);
    }

    public ReentrantReadWriteLock1.WriteLock writeLock() {
        return writerLock;
    }

    public ReentrantReadWriteLock1.ReadLock readLock() {
        return readerLock;
    }

    abstract static class Sync extends AbstractQueuedSynchronizer1 {//ReentrantLock有自己的Sync，都继承AQS类，
        private static final long serialVersionUID = 6317671515068378041L;

        static final int SHARED_SHIFT = 16;
        static final int SHARED_UNIT = (1 << SHARED_SHIFT);// 2^16
        static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;// 2^16-1
        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;// 2^16-1

        static int sharedCount(int c) {//小于2^16=0，等于2^16=1，大于2^16>1，共享锁最大共享线程数=2^16-1，
            return c >>> SHARED_SHIFT;// 右移16位，
        }

        static int exclusiveCount(int c) {
            return c & EXCLUSIVE_MASK;// 去掉前面16位，
        }

        static final class HoldCounter {
            int count = 0;
            final long tid = getThreadId(Thread.currentThread());
        }

        static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
            public HoldCounter initialValue() {
                return new HoldCounter();//ThreadLocalHoldCounter作为key,new HoldCounter()作为value，
            }
        }

        //当前线程持有的可重入读锁的数量。构造函数中初始化。每当线程的读计数下降到0时删除。
        private transient ThreadLocalHoldCounter readHolds;//只有一个

        private transient HoldCounter cachedHoldCounter;//多个

        private transient Thread firstReader = null;
        private transient int firstReaderHoldCount;

        Sync() {
            readHolds = new ThreadLocalHoldCounter();//只有一个
            setState(getState());  
        }
        
        abstract boolean readerShouldBlock();
        abstract boolean writerShouldBlock();

        protected final boolean tryRelease(int releases) {//写锁释放
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;// 状态变量的值减1
            boolean free = exclusiveCount(nextc) == 0;//写锁=0
            if (free)//getState()-releases == 0
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

        protected final boolean tryAcquire(int acquires) {//WriteLock获取锁，多线程访问
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);//w=0则C=2^16,w!=0则C<2^16，写锁被获取的次数
            
            if (c != 0) {//锁里面有线程了重入锁，写锁只要看见state里面有线程就去排队（可能里面有读锁或者写锁），
                
                // c!=0，w=0：说明C=2^16的整数倍，说明有读线程获取了锁，
                if (w == 0 || current != getExclusiveOwnerThread())  // c!=0，w=0，说明有读锁进去，写锁不进去，其它线程获取了互斥锁（写锁）
                    return false;//获取锁失败去排队
                
                /*单线程进来，线程安全的。 */
                
                //w!=0&&current=OwnerThread，MAX_COUNT=2^16-1，就去加值，
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                //w!=0&&current=OwnerThread，MAX_COUNT=2^16-1，就去加值，
                setState(c + acquires);//acquires每次都是从1开始的，C从0开始，所以c,w,acquires不可能大于2^16。
                return true;
            }
            //c=0，锁里面没有线程，就要去抢锁。
            //writerShouldBlock：非公平返回false，就去获取锁。
            //writerShouldBlock:公平，返回true排队，返回false，就去获取锁。
            //获取state成功设置owenerThread=自己，不去排队，获取state失败，去排队。
            if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
                return false;
            
            /*单线程进来，线程安全的。 
            compareAndSetState(c, c+acquires)可以作为一把锁，synchronized，
             别的线程要想进到compareAndSetState包裹的代码里面去，必须重新获取新的c=c+acquires，但是进去if(c!=0)里面去了。
             */
            
            setExclusiveOwnerThread(current);//获得锁。
            return true;
        }

        protected final boolean tryReleaseShared(int unused) {// 读锁释放（共享锁），unused没有使用
            Thread current = Thread.currentThread();
            if (firstReader == current) {
                // 如果第一个读者（读线程）是当前线程
                 // 就把它重入的次数减1
                 // 如果减到0了就把第一个读者置为空
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                // 如果第一个读者不是当前线程，一样地，把它重入的次数减1
                HoldCounter rh = cachedHoldCounter;//最后获取读锁的HoldCounter
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();//get方法没有时候，就回去创建，有就返回。返回当前线程threadLcoalMap里面的那行记录
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;
            }
            for (;;) {// 共享锁获取的次数减1，如果减为0了说明完全释放了，才返回true
                int c = getState();
                int nextc = c - SHARED_UNIT;//减去65536
                if (compareAndSetState(c, nextc))
                    return nextc == 0;//读锁完全释放了，
            }
        }

        private IllegalMonitorStateException unmatchedUnlockException() {
            return new IllegalMonitorStateException("attempt to unlock read lock, not locked by current thread");
        }

        //读锁每次进来加65536，写锁每次进来加1，
        protected final int tryAcquireShared(int unused) {//ReadLock获取锁，走这个方法，并发问题，unused没有使用
            // 在读写锁模式下，高16位存储的是共享锁（读锁）被获取的次数，低16位存储的是互斥锁（写锁）被获取的次数
            Thread current = Thread.currentThread();
            int c = getState();//state在AQS类里面，读锁写锁，公用一个Sync AQS state，写锁只能一个进去，另一个写锁进不去，读锁也进不去，
            if (exclusiveCount(c) != 0 /*去掉前面16位，*/ && getExclusiveOwnerThread() != current)//state!=0，并且 当前线程没有获取锁。如果写线程获取了锁，state+1就返回-1去排队。
                return -1;
            int r = sharedCount(c);//右移16位， 读锁被获取的次数
            //多线程可以进来
            if (!readerShouldBlock()/* AQS队列第一个节点写线程跳过，没有第一个节点或者第一个是读线程就进去 */ && r < MAX_COUNT 
                    && compareAndSetState(c, c + SHARED_UNIT)/* c每次增加65536 */) {
                //可以多线程进来，AQS队列没有节点  并且  c是2^16的整数倍=0就是没有写锁，第一个线程进来后只要后面的线程重新获取c就可以进来，
                
                // 注意下面对firstReader的处理：firstReader是不会放到readHolds里的
                 // 这样，在读锁只有一个的情况下，就避免了查找readHolds。
                if (r == 0) {//r=0,c<2^16，没有读锁
                    firstReader = current;//获取读锁的线程，Thread
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {//重入锁
                    firstReaderHoldCount++;
                } else {
                    //先查缓存
                    HoldCounter rh = cachedHoldCounter;//HoldCounter，缓存前一个线程的HoldCounter（线程id和获取锁次数）
                    if (rh == null || rh.tid != getThreadId(current))
                        //ThreadLocal里面get，ThreadLocalHoldCounter。
                        //当前线程的threadLocals属性的threadLocalMap里面加了一行记录（key=readHolds[ThreadLocalHoldCounter]，value=cachedHoldCounter[HoldCounter]），
                        //其他线程也会在他的threadLocals的threadLocalMap里面加一行记录（key=readHolds[ThreadLocalHoldCounter]，value=cachedHoldCounter[HoldCounter]），
                        //每个线程里面只有一行记录，ThreadLocal是公用的，因为只有一个ThreadLocal，value放的是线程的id和计数器。就这样线程就获取了锁，
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)//当前线程就是上一次线程，就修改thradLocals
                        readHolds.set(rh);
                    rh.count++;//多个读，只有一个firstReader，其余的都是在线程里面的threadLocals里面加了一行记录，重入的次数加1（初始次数为0）
                }
                return 1;//获取了锁
            }
            //有人在排队
            return fullTryAcquireShared(current);
        }

        //在tryAcquireShared中经行了一次快速锁获取，但是由于CAS只能允许一个线程获取锁成功，且读锁是共享的，
        //可能存在其他仍然可以获取锁的线程，所以在函数末尾调用函数fullTryAcquireShared来进行死循环的获取锁，
        final int fullTryAcquireShared(Thread current) {//获取读锁
            HoldCounter rh = null;
            for (;;) {//死循环
                int c = getState();
                if (exclusiveCount(c) != 0) {//去掉前面16位!= 0
                    if (getExclusiveOwnerThread() != current)//相等，就是先获取写锁在获取读锁，
                        return -1;//排队
                    // 否则，我们持有独占锁；在这里阻塞将导致死锁。
                } else if (readerShouldBlock()) {//去掉前面16位= 0，并且AQS队列有第一个节点是写锁不是读锁，
                    // 确保我们没有重新获取读锁
                    if (firstReader == current) {
                        // assert firstReaderHoldCount > 0;
                    } else {
                        if (rh == null) {
                            rh = cachedHoldCounter;
                            if (rh == null || rh.tid != getThreadId(current)) {
                                rh = readHolds.get();//设置当前线程的threadLocals，key还是readHolds同一个ThreadLocal，
                                if (rh.count == 0)//!=0，就说明这个线程之前已经获取一次锁成功了，
                                    readHolds.remove();//从当前线程threadLocals中移除这行记录，
                            }
                        }
                        if (rh.count == 0)
                            return -1;//排队，
                    }
                }
                
                //AQS没有节点，有第一个节点，第一个节点只能是读节点，就去设置threadLcoalMap并且获取锁，
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    if (sharedCount(c) == 0) {//=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;//获取了锁
                }
            }
        }

        final boolean tryWriteLock() {
            Thread current = Thread.currentThread();
            int c = getState();
            if (c != 0) {
                int w = exclusiveCount(c);
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
            }
            //c=0
            if (!compareAndSetState(c, c + 1))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

        final boolean tryReadLock() {
            Thread current = Thread.currentThread();
            for (;;) {
                int c = getState();
                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)) {
                    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;
                }
            }
        }

        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        final Thread getOwner() {
            return ((exclusiveCount(getState()) == 0) ? null : getExclusiveOwnerThread());
        }

        final int getReadLockCount() {
            return sharedCount(getState());
        }

        final boolean isWriteLocked() {
            return exclusiveCount(getState()) != 0;
        }

        final int getWriteHoldCount() {
            return isHeldExclusively() ? exclusiveCount(getState()) : 0;
        }

        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 void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            readHolds = new ThreadLocalHoldCounter();
            setState(0); // reset to unlocked state
        }

        final int getCount() {
            return getState();
        }
    }

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;

        final boolean writerShouldBlock() {//false获取锁。
            return false;  
        }

        final boolean readerShouldBlock() {// 非公平读是否要阻塞，true排队，false获取锁。
            return apparentlyFirstQueuedIsExclusive();//AQS队列有第一个节点是写锁不是读锁，
        }
    }

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;

        final boolean writerShouldBlock() {// 公平写是否要阻塞，true排队，false获取锁。
            return hasQueuedPredecessors();
        }

        final boolean readerShouldBlock() {// 公平读是否要阻塞，true排队，false获取锁。
            return hasQueuedPredecessors();
        }
    }

    public static class ReadLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -5992448646407690164L;
        private final Sync sync;

        protected ReadLock(ReentrantReadWriteLock1 lock) {// 外部类this
            sync = lock.sync;
        }

        public void lock() {//获取读锁，获取的是共享锁，调用sync.acquireShared（AQS的方法），写锁调用sync.acquire（AQS的方法）
            try {
                sync.acquireShared(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void lockInterruptibly() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }

        public boolean tryLock() {
            return sync.tryReadLock();
        }

        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
        }

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

        public Condition newCondition() {
            throw new UnsupportedOperationException();
        }

        public String toString() {
            int r = sync.getReadLockCount();
            return super.toString() + "[Read locks = " + r + "]";
        }
    }

    public static class WriteLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -4992448646407690164L;
        private final Sync sync;

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

        public void lock() {//获取写锁，写锁的获取逻辑和ReentrantLock一样，失败的加入AQS队列，
            try {//读锁调用sync.acquireShared（AQS的方法），写锁调用sync.acquire（AQS的方法）
                sync.acquire(1);//尝试获取锁，获取失败就在AQS阻塞排队
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void lockInterruptibly() throws InterruptedException {
            sync.acquireInterruptibly(1);
        }

        public boolean tryLock() {
            return sync.tryWriteLock();//获取读锁，不在AQS类里面，在本Sync类里面，
        }

        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireNanos(1, unit.toNanos(timeout));
        }

        public void unlock() {
            sync.release(1);//写锁释放，线程安全，唤醒AQS头结点，
        }

        public Condition newCondition() {
            return sync.newCondition();
        }

        public String toString() {
            Thread o = sync.getOwner();
            return super.toString() + ((o == null) ? "[Unlocked]" : "[Locked by thread " + o.getName() + "]");
        }

        public boolean isHeldByCurrentThread() {
            return sync.isHeldExclusively();
        }

        public int getHoldCount() {
            return sync.getWriteHoldCount();
        }
    }

    public final boolean isFair() {
        return sync instanceof FairSync;
    }

    protected Thread getOwner() {
        return sync.getOwner();
    }

    public int getReadLockCount() {
        return sync.getReadLockCount();
    }

    public boolean isWriteLocked() {
        return sync.isWriteLocked();
    }

    public boolean isWriteLockedByCurrentThread() {
        return sync.isHeldExclusively();
    }

    public int getWriteHoldCount() {
        return sync.getWriteHoldCount();
    }

    public int getReadHoldCount() {
        return sync.getReadHoldCount();
    }

    protected Collection<Thread> getQueuedWriterThreads() {
        return sync.getExclusiveQueuedThreads();
    }

    protected Collection<Thread> getQueuedReaderThreads() {
        return sync.getSharedQueuedThreads();
    }

    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }

    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer1.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer1.ConditionObject) condition);
    }

    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer1.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer1.ConditionObject) condition);
    }

    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer1.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer1.ConditionObject) condition);
    }

    public String toString() {
        int c = sync.getCount();
        int w = Sync.exclusiveCount(c);
        int r = Sync.sharedCount(c);

        return super.toString() + "[Write locks = " + w + ", Read locks = " + r + "]";
    }

    // Thread Id可以被重写
    static final long getThreadId(Thread thread) {
        return UNSAFE.getLongVolatile(thread, TID_OFFSET);
    }

    private static final sun.misc.Unsafe UNSAFE;
    private static final long TID_OFFSET;
    static {
        try {
            UNSAFE = java.security.AccessController
                    .doPrivileged(new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
                        public sun.misc.Unsafe run() throws Exception {
                            Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
                            for (java.lang.reflect.Field f : k.getDeclaredFields()) {
                                f.setAccessible(true);
                                Object x = f.get(null);
                                if (k.isInstance(x))
                                    return k.cast(x);
                            }
                            throw new NoSuchFieldError("the Unsafe");
                        }
                    });
            Class<?> tk = Thread.class;
            TID_OFFSET = UNSAFE.objectFieldOffset(tk.getDeclaredField("tid"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

}