队列同步器AbstractQueuedSynchronizer源

AQS 是实现大部分同步组件的基础

被推荐为定义为自定义同步组件的非public静态内部类

1. 通过AQS提供的如下方法对需要用户重写的方法（要修改同步器状态）提供了支持

2. 需要重写的方法

3. 对外暴露的模板方法

4. 模板设计模式

模板设计模式的意图是定义算法的整体骨架，然后将部分针对特定细节的部分声明为抽象方法逼迫子类去实现（AQS是抛出异常，而不是定义为抽象方法）

5. 例子

这是AQS源码附带的实例程序

public class Mutex implements Lock {
    private static class Sync extends AbstractQueuedSynchronizer {
        //是否处于占用状态
        protected boolean isHeldExclusive() {
            return getState() == 1;
        }
        //当状态为 0 时获取锁
        @SuppressWarnings("Since15")
        public boolean tryAcquired(int acquires) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        //释放锁，将状态设置为 0
        @SuppressWarnings("Since15")
        protected boolean tryRelease(int releases) {
            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        //返回一个Condition，每个condition都包含了一个condition的对队列
        Condition newCondition(){
            return new ConditionObject();
        }
    }
    //仅仅将操作代理到 Sync 上即可
    private final Sync sync = new Sync();
    public void lock() {
        sync.acquire(1);
    }
    public boolean tryLock() {
        return sync.tryAcquired(1);
    }
    public void unlock() {
        sync.release(1);
    }
    public Condition newCondition() {
        return sync.newCondition();
    }
    public boolean isLocked(){
        return sync.isHeldExclusive();
    }
    public boolean hasQueuedThread(){
        return sync.hasQueuedThreads();
    }
    public void lockInterruptibly() throws InterruptedException{
        sync.acquireInterruptibly(1);
    }
    public boolean tryLock(long timeOut, TimeUnit unit) throws InterruptedException{
        return sync.tryAcquireNanos(1,unit.toNanos(timeOut));
    }
}

在自定义同步组件中的public方法中，去调用静态内部类AQS的模板方法，来实现其自定义的同步功能。