AbstractQueuedSynchronizer简单理解及介绍

        AbstractQueuedSynchronizer是一个抽象同步队列器，它的作用是提供一个框架，简化程序员对锁，同步控制工具的开发。如果从零开发一个可重入的独占锁，程序员至少需要做以下的处理，先尝试获取锁，如果获取锁失败，则线程进入阻塞，等待“释放锁线程”唤醒，而有了AQS,程序员只需要继承AQS类，实现“尝试获取锁”方法，实现"尝试释放锁"，就可以轻松实现可重入独占锁了。 

如下代码所示，定义一个Sync的内部类，继承了AbstractQueuedSynchronizer,实现了tryAcquire跟tryRelease方法，tryAcquire是尝试获取锁方法，tryRelease是尝试释放锁方法，通过AbstractQueuedSynchronizer定义的state变量，来定义当前锁的状态，下面的锁state>0表示已经有线程占有锁，以及占有锁线程的重入次数。

public class MyReentrantLock implements Lock {
    private Sync sync=new Sync();
    @Override
    public void lock() {
        sync.acquire(1);
    }

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

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1,time);
    }

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

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

    /**
     * 继承AbstractQueuedSynchronizer,重写tryAcquire，tryRelease方法.就可以实现可重入独占锁。
     */
    public class Sync extends AbstractQueuedSynchronizer{
        /**
         * 尝试获取锁逻辑
         * @param arg
         * @return
         */
        @Override
        protected boolean tryAcquire(int arg) {
            if(compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            if(getExclusiveOwnerThread()==Thread.currentThread()){
                setState(getState()+1);
                return true;
            }
            return false;
        }

        /**
         *尝试释放所
         * @param arg
         * @return
         */
        @Override
        protected boolean tryRelease(int arg) {
            if(getExclusiveOwnerThread()!=Thread.currentThread()){
                throw new RuntimeException();
            }
            int state = getState() - 1;
            //减少可重入次数
            if(state>0){
                setState(state);
                return false;
            }
            //释放锁
            setState(state);
            setExclusiveOwnerThread(null);
            return true;

        }
        //
     Condition newCondition() { return new ConditionObject(); }

    }
}

AbstractQueuedSynchronizer的作用远不止如此，还可以通过它实现共享锁，读写锁，同步控制工具等。

补充：
通过选择性重写这五个方法，结合state变量，可以实现共享锁，读写锁，同步控制工具等，这些源码会在后面博客进行说明。
* <li> {@link #tryAcquire}
* <li> {@link #tryRelease}
* <li> {@link #tryAcquireShared}
* <li> {@link #tryReleaseShared}
* <li> {@link #isHeldExclusively}