并发包独占锁ReentrantLock与读写锁ReentrantReadWriteLock

两个锁都是依赖AQS实现的，方法基本是Sync的封装，主要看Sync的设计实现，

一、可重入独占锁ReentrantLock

1.静态内部抽象类Sync

    //继承AQS
　　abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * 延迟到子类实现（公平锁与非公平锁）
         */
        abstract void lock();

        /**
         * 尝试获取非公平锁
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                //计数器state == 0：锁未被持有，计数器原子性自增并设置当前线程为持有者
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                //计数器state != 0：锁被当前线程为持有者，计数器state增加（可重入锁）
                int nextc = c + acquires;
                if (nextc < 0) // 可重入次数溢出跑错
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                //当前线程不是锁的持有者抛出异常
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                //计数器state == 0：释放锁，设置持有者为null
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            //判断当前线程是否为锁的持有者
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            //创建条件变量
            return new ConditionObject();
        }

        // Methods relayed from outer class

        final Thread getOwner() {
            //获取当前锁的持有线程
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            //当前线程为锁的持有者返回计数器state值，不是锁的持有者返回0
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            //锁是否被持有
            return getState() != 0;
        }

        /**
         * 创建反序列化实例，重置计数器值，锁状态初始化
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

继承Sync的非公平锁NonfairSync与公平锁FairSync

    /**
     * 非公平锁
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                //当前计数器state == 0即锁未被持有时，state自增且直接设置当前线程为锁持有者（未检查阻塞队列，破坏FIFO）
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //当前计数器state != 0即锁被持有时，调用AQS的独占模式获取资源，会调用下面的tryAcquire尝试获取锁
                acquire(1);
        }

        //acquire方法中tryAcquire实现，尝试获取锁，若锁未被持有，直接获取锁，不入阻塞队列，破坏FIFO
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    /**
     * 公平锁
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * 公平锁尝试获取资源，锁未被持有时，先队列，后当前线程
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                //计数器state == 0，锁未被持有
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //AQS阻塞队列为空或者当前线程是阻塞队列头结点的后继节点，直接设置当前线程为锁的持有者，计数器state自增
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                //计数器state != 0.锁被持有且持有者是当前线程，计数器state自增
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

2.ReentrantLock的变量与构造方法

    private final Sync sync;//实际的锁对象

    public ReentrantLock() {
        sync = new NonfairSync();//无参构造函数默认非公平锁 == ReentrantLock(false)
    }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();//可指定公平锁还是非公平锁
    }

3.ReentrantLock的方法：都是Sync的封装

    //尝试获取锁
    public void lock() {
        sync.lock();
    }

    //尝试获取锁，不忽略中断，中断抛错
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    //尝试获取锁
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    //尝试一定时间内获取锁
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

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

    //创建条件变量
    public Condition newCondition() {
        return sync.newCondition();
    }

    //返回锁的重入数，不是锁持有者则返回0
    public int getHoldCount() {
        return sync.getHoldCount();
    }

    //判断当前线程是否为锁的持有者
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }

    //判断锁是否被持有
    public boolean isLocked() {
        return sync.isLocked();
    }

    //判断是否公平锁
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

    //获取锁的持有者
    protected Thread getOwner() {
        return sync.getOwner();
    }


    //判断AQS队列是否为空
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    //判断线程是否在AQS队列中
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }
    
    //获取AQS阻塞队列长度（不包括头尾节点）
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    //获取AQS阻塞队列中的线程集合
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }
    //条件变量是否存在条件队列
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    //获取条件变量的条件队列长度
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }
    
    //获取条件变量的条件队列中的线程集合
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

3.独占锁实例

public class ReentrantLockTest {

    private ArrayList<String> list = new ArrayList<>();
    private volatile ReentrantLock lock = new ReentrantLock();

    public void add(String e){
        lock.lock();
        try {
            list.add(e);
        }finally {
            lock.unlock();
        }
    }

    public void remove(String e){
        lock.lock();
        try {
            list.remove(e);
        }finally {
            lock.unlock();
        }
    }

    public String get(int index){
        lock.lock();
        try {
            return list.get(index);
        }finally {
            lock.unlock();
        }
    }
}

二、可重入读写锁ReentrantReadWriteLock

弄清楚读写锁原理，首先需弄清楚读线程与写线程时线程安全关系

读读：线程安全 ，此时读不需要加锁的

写写：线程不安全，此时写需要加锁，写完之后，再写

读写：线程不安全，此时读需要加锁，读完之后，再写

写读：线程不安全，此时写需要加锁，写完之后，再读

因此读写锁ReentrantReadWriteLock实现时，将读锁实现为共享锁（多个线程持有），写锁实现为独占锁（单个线程持有），读写或写读时，读写锁进行互斥判断。即

读读：两个读线程可持有同一把读锁（共享锁特性），同时读

写写：第一个写线程持有写锁，写完之后，第二个写线程才能获取写锁（独占锁特性）

读写：读线程获取读锁，写线程需等读锁释放后才能获取写锁（读写锁互斥判断，读时不能写）

写读：写线程获取写锁，读线程需等写锁释放后才能获取读锁（读写锁互斥判断，写时不能读）

综上也可以看出为什么读操作需要加锁？

1.读锁是共享锁，读读可同时执行，此时跟没有加锁一样。

2.主要为了读写互斥，读锁与写锁是两个平行的锁，不相关的，但代码中加了逻辑判断，读锁被持有时，写锁不能被持有，写锁持有时读锁不能被持有，即读时不能写，写时不能读

下面看具体实现：

 1、静态内部抽象类Sync

ReentrantReadWriteLock也是计数器实现的，读写锁是两个锁，但仅有一个state变量。因此将state状态值的高16位作为读锁的计数器，低16位作为写锁的计数器。

读锁采用AQS共享模式实现，写锁采用AQS独占模式实现

即读锁是一个可重入共享锁，写锁是一个可重入独占锁

与可重入独占锁ReentrantLock相比，Sync中定义了HoldCounter（线程持有锁的重入数）与ThreadLocalHoldCounter（ThreadLocal实现，将HoldCounter存入Thread的ThreadLocalMap中）两个静态内部最终类

1）变量与构造方法、内部类

    static final int SHARED_SHIFT   = 16;//位运算使用，取高16位或低16位
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);//读锁计数器增加单位，用于高16位的末位加1
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;//读锁的最大线程数，写锁的最大可重入数
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;//写锁掩码，用于获取写锁的计数器值： state & EXCLUSIVE_MASK
    private transient ThreadLocalHoldCounter readHolds;//当前线程的读锁重入数，ThreadLocal实现，仅构造方法及反序列化初始化，将至0时删除
    private transient HoldCounter cachedHoldCounter;//读锁的最后一个线程的重入数
    private transient Thread firstReader = null;//获取读锁的第一个线程
    private transient int firstReaderHoldCount;//获取读锁的第一个线程的重入数

    //无参构造方法，初始化ThreadLocal及state
    Sync() {
        readHolds = new ThreadLocalHoldCounter();
        setState(getState()); // ensures visibility of readHolds
    }

    //线程可重入数  tid--count
    static final class HoldCounter {
        int count = 0;
        final long tid = getThreadId(Thread.currentThread());
    }

    //ThreadLocal将线程可重入数存入Thread的ThreadLocalMap中
    static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
        public HoldCounter initialValue() {
            return new HoldCounter();
        }     
    }

2）方法

公平锁与非公平锁的判断，具体实现延迟到子类公平锁FairSync与非公平锁NonfairSync

        abstract boolean readerShouldBlock();//读锁是否使用公平锁
        abstract boolean writerShouldBlock();//写锁是否使用公平锁

AQS独占模式：线程尝试获取写锁与释放写锁（独占模式tryAcquire及tryRelease的实现）

写锁是可重入独占锁，所以

1.写写时与ReentrantLock实现类似，但多了读写时判断，读时不能写，

2.写锁计数器值（state低16位）是写锁持有者重入数

        protected final boolean tryAcquire(int acquires) {
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            if (c != 0) { //计数器不等于0；锁已被持有，但不能确定是读锁还是写锁被持有
                if (w == 0 || current != getExclusiveOwnerThread())
                    //w == 0即写锁未被持有，读锁被持有，入AQS阻塞队列（读时不能写）
                    //当前线程不是写锁持有线程时，入AQS阻塞队列
                    return false;
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    //超出写锁最大可重入数抛出错误
                    throw new Error("Maximum lock count exceeded");
                // 写锁计数器更新
                setState(c + acquires);
                return true;
            }
            //c == 0即读锁与写锁都未被持有
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                //公平锁 || 计数器更新失败
                return false;
            setExclusiveOwnerThread(current);//更新写锁持有者
            return true;
        }

        protected final boolean tryRelease(int releases) {
            if (!isHeldExclusively())
                //当前线程不是写锁持有者，抛出异常
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            //写锁计数器 == 0 ，释放写锁资源，设置写锁未被持有，更新state
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

AQS共享模式：线程尝试获取读锁与释放读锁（共享模式tryAcquireShared与tryReleaseShared的实现）

读锁是可重入共享锁，所以

1.读读时类似于没有锁，但读写时读锁与写锁互斥判断，写时不能读，

2.读锁计数器值（state高16位）是读锁多个持有线程的重入数之和

3.为标识各个线程的重入数，引入了上面提到过的HoldCounter类，保存线程的读锁重入数，采用ThreadLocal实现

        protected final int tryAcquireShared(int unused) {
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                //写时不能读，写锁被持有时读操作阻塞
                return -1;
            int r = sharedCount(c);
            if (!readerShouldBlock() &&  //读锁是否公平锁
                r < MAX_COUNT &&  //读锁计数器小于最大值
                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 1;
            }
            //公平锁 || 超出读锁最大重入数 || 非公平锁获取锁失败
            return fullTryAcquireShared(current);
        }

        final int fullTryAcquireShared(Thread current) {
            HoldCounter rh = null;
            for (;;) {
                int c = getState();
                 //重新判断写锁状态
                if (exclusiveCount(c) != 0) {
                    if (getExclusiveOwnerThread() != current)
                        return -1;
                } else if (readerShouldBlock()) {//读锁是公平锁
                    // Make sure we're not acquiring read lock reentrantly
                    // 确保没有以可重入方式获取读锁
                    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");
                if (compareAndSetState(c, c + SHARED_UNIT)) {//获取读锁，更新读锁计数器
                    if (sharedCount(c) == 0) {
                        //设置第一个获取读锁的线程，重入数
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        //更新第一个获取读锁的线程的重入数
                        firstReaderHoldCount++;
                    } else {
                        //设置或更新最后一个获取线程的重入数的缓存cache
                        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;
                }
            }
        }

        protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            if (firstReader == current) {
                // 当前线程是获取读锁的第一个线程，
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                //更新当前线程可重入数，若是重入数<=1,删除HoldCounter
                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))
                    return nextc == 0;
            }
        }

 其他方法，大部分与ReentrantLock类似

        /**
         * 尝试获取写锁，与tryAcquired类似，但公平锁判断，直接非公平锁的实现
         */
        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");
            }
            if (!compareAndSetState(c, c + 1))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

        /**
         * 尝试获取读锁，与tryAcquiredShared类似，但公平锁判断，直接非公平锁实现
         */
        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(); }

3）公平锁与非公平锁的实现：仅重写了读写锁是否公平锁的判断方法

    /**
     * 非公平锁，先当前线程后队列，非FIFO
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;
        final boolean writerShouldBlock() {
            return false; // writers can always barge
        }
        final boolean readerShouldBlock() {
            /**/
            return apparentlyFirstQueuedIsExclusive();
        }
    }

    /**
     * 公平锁，先队列，后当前线程FIFO
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;
        final boolean writerShouldBlock() {
            return hasQueuedPredecessors();
        }
        final boolean readerShouldBlock() {
            return hasQueuedPredecessors();
        }
    }

4）读写锁（Sync封装使用,很简单，注意绿色）

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

        /**
         * 构造方法，参数不能为null，NullPointerException
         */
        protected ReadLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }
 
        public void lock() {
            sync.acquireShared(1);
        }

        public void lockInterruptibly() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
 
        //尝试获取读锁，不入AQS阻塞队列
        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;

        /**
         * 构造方法，参数不能为null,NullPointerException
         */
        protected WriteLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }

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

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

        //尝试获取写锁，失败不入AQS阻塞队列
        public boolean tryLock( ) {
            return sync.tryWriteLock();
        }

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

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

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

2.ReentrantReadWriteLock

1）变量与构造方法

    /** 读锁 */
    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; }

2）其他方法实现与ReentrantLock一样都是对Sync的封装使用

    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 AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

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

    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.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 + "]";
    }

    static final long getThreadId(Thread thread) {
        return UNSAFE.getLongVolatile(thread, TID_OFFSET);
    }

3、读写锁实例

public class ReentrantReadWriteLockTest {

    private ArrayList<String> list = new ArrayList<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    public void add(String e){
        writeLock.lock();
        try {
            list.add(e);
        }finally {
            writeLock.unlock();
        }
    }

    public void remove(String e){
        writeLock.lock();
        try {
            list.remove(e);
        }finally {
            writeLock.unlock();
        }
    }

    public String get(int index){
        readLock.lock();
        try {
            return list.get(index);
        }finally {
            readLock.unlock();
        }
    }
}

三、补充JDK1.8新增StampedLock（提供读写锁装换和乐观读锁，给锁加了个版本）

StampedLock锁提供三种模式的读写控制；获取锁时，会返回一个long型的变量stamp，可以看做锁的时间戳版本，释放锁时需要传入stamp

writeLock():获取写锁，返回一个stamp，使用类似于ReentrantReadWriteLock的写锁，但它是一个不重入锁；释放锁时需要传入stamp

readLock()：获取悲观读锁，返回一个stamp，使用类似于ReentrantReadWriteLock的读锁（同样与写锁互斥），但也是一个不重入锁；释放锁时需要传入stamp

tryOptimisticRead()：获取乐观读锁，返回一个stamp，先获取数据，需要用到数据前，stamp校验，由于读锁类似共享锁stamp不变，所以stamp改变说明被写线程抢占过，

即校验通过，直接操作数据；校验不通过，重新使用悲观读锁获取数据操作。

乐观锁：先获取数据并标记版本，使用时检测数据版本是否改变，改变需要重新获取，未改变直接使用（读多写少时提高了并发效率）

public class StampedLockTest {

    private double x,y;

    private final StampedLock lock = new StampedLock();

    void move(double deltaX, double deltaY){
        //写锁--不重入独占锁
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        }finally {
            lock.unlockWrite(stamp);
        }
    }

    double distanceFromOrigin(){
        //乐观读锁  实际使用时检测锁的状态，提高了效率
        long stamp = lock.tryOptimisticRead();
        double currentX = x;
        double currentY = y;
        //实际操作数据前需要检测锁的状态，stamp改变即被写锁抢占过
        if (!lock.validate(stamp)){
            //悲观读锁重新获取数据
            stamp = lock.readLock();
            try {
                currentX = x;
                currentY = y;
            }finally {
                lock.unlockRead(stamp);
            }
        }
        //数据线程安全，但可能是快照
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    void moveIfAtOrigin(double newX, double newY){
        //悲观读锁--不重入共享锁
        long stamp = lock.readLock();
        try {
            while (x == 0.0 && y == 0.0){
                //尝试读锁转换为写锁
                long ws = lock.tryConvertToWriteLock(stamp);
                if (ws != 0L){
                    stamp = ws;
                    x = newX;
                    y = newY;
                    break;
                }else {
                    lock.unlockRead(stamp);
                    stamp = lock.writeLock();
                }
            }
        }finally {
            lock.unlock(stamp);
        }
    }
}

@since错误需修改maven编译器默认的jdk版本（1.5）

        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>

四、总结

1、用AQS中state变量充当计数器实现了可重入独占锁ReentranLock与可重入读写锁ReentrantReadWriteLock(高16位：读锁计数器；低16位：写锁计数器),自主实现公平锁与非公平锁

2、读多写少的场景ReentranLock(读写都独占锁) < ReentrentReadWriteLock（读：共享锁；写：独占锁） < StampedLock（读：乐观锁+悲观锁；写：独占锁）

参考自《java并发编程之美》