基于 AQS 实现读写锁

AQS -- AbstractQueuedSynchronizer

首先介绍一下 AbstractQueuedSynchronizer （抽象队列同步器）:

队列同步器AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者其他同步组件的基础框架；位于 java.util.concurrent.locks 包下;

它使用了一个信号量(state)表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作；

AbstractQueuedSynchronizer 使用的是模版模式，他内置了 获取锁、释放锁的方法，使用者无需关心锁获取失败或成功之后的操作，只需要重写锁获取或释放的条件判断即可使用；

package java.util.concurrent.locks;

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

    //获取独占锁
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

    //释放独占锁
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
   
    //获取共享锁
    public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }


    //释放共享锁
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }
       
    //获取当前星号量的值
    protected final int getState() {
        return state;
    }

    //CAS 操作 更新 锁状态信号量 state
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    
    // 设置当前线程 为独占线程
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    
    .......


    //尝试获取 独占锁 需要 使用者重写 
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

    
    //尝试释放独占锁  需要 使用者重写
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
    
    //尝试获取 共享锁 需要 使用者重写
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

    //尝试释放 共享锁 需要 使用者重写
    protected boolean tryReleaseShared(int arg) {
        throw new Unsu