AbstractQueuedSynchronizer

AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包
AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。
CLH（Craig，Landin，and Hagersten）队列是一个虚拟的双向队列，虚拟的双向队列即不存在队列实例，仅存在节点之间的关联关系。
用大白话来说，AQS就是基于CLH队列，用volatile修饰共享变量state，线程通过CAS去改变状态符，成功则获取锁成功，失败则进入等待队列，等待被唤醒。
CAS(Compare and Swap) 科普

如字面意思，就是先比较再替换，

cas方法有三个重要参数 : 待比较的值、预期值、要修改的新值，如果预期值是待比较的值一致，那么就把要修改的值赋值给待比较的值

伪代码如下:
```
Object old; // 待比较的值
Object new; // 预期值
Object update;// 要修改的新值
if(old == new) {
    old = update;
}
```
CAS（比较并交换）是CPU指令级的操作，只有一步原子操作，所以非常快。而且CAS避免了请求操作系统来裁定锁的问题，不用麻烦操作系统，直接在CPU内部就搞定了。

java中操作cas:
```
sun.misc.Unsafe unsafe = sun.misc.Unsafe.getUnsafe();
Demo old = new Demo();
long offset = unsafe.objectFieldOffset
                (Demo.class.getDeclaredField("id"))
    // 如果 old.id 是 1， 那么修改成 2
return unsafe.compareAndSwapObject(old, offset, 1, 2);
```
AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）
- 独占锁API
  - **isHeldExclusively()**：该线程是否正在独占资源。只有用到condition才需要去实现它。
    
    aqs未实现该方法，需要手动实现，判断当前线程是否已获得资源，返回boolean
  - **tryAcquire(int)**：独占方式。尝试获取资源，成功则返回true，失败则返回false。
    
    aqs抽象类未实现该方法，一般都需要重写该方法
  - **tryRelease(int)**：独占方式。尝试释放资源，成功则返回true，失败则返回false。
    
    aqs抽象类未实现该方法，一般需要重写该方法来释放资源
- 共享锁API
  - **tryAcquireShared(int)**：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
    
    aqs抽象类未实现该方法，一般都需要重写该方法
  - **tryReleaseShared(int)**：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。aqs抽象类未实现该方法，一般需要重写该方法来释放资源
- 独占api和共享api的区别
  - 当AQS的子类实现独占功能时，如 ReentrantLock，资源是否可以被访问被定义为：只要AQS的state变量不为0，并且持有锁的线程不是当前线程，那么代表资源不可访问。
  - 当AQS的子类实现共享功能时，如CountDownLatch，资源是否可以被访问被定义为：只要AQS的state变量不为0，那么代表资源不可以为访问。
  - ReentrantReadWriteLock 中读锁用的共享锁，写锁用的独占锁
- 独占锁例子
  - ReentrantLock为例，（可重入独占式锁）：state初始化为0，表示未锁定状态，A线程lock()时，会调用**tryAcquire() **独占锁并将state+1.之后其他线程再想tryAcquire的时候就会失败，直到A线程unlock（）到state=0为止，其他线程才有机会获取该锁。A释放锁之前，自己也是可以重复获取此锁（state累加），这就是可重入的概念。注意：获取多少次锁就要释放多少次锁，保证state是能回到零态的。
- 共享锁例子
  - 以CountDownLatch为例，任务分N个子线程去执行，state就初始化为N，N个线程并行执行，每个线程执行完之后countDown（）一次，state就会CAS减一。当N子线程全部执行完毕，state=0，会unpark()主调用线程，主调用线程就会从await()函数返回，继续之后的动作。
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。 　在acquire() acquireShared()两种方式下，线程在等待队列中都是忽略中断的，acquireInterruptibly()/acquireSharedInterruptibly()是支持响应中断的。

**注意：AQS是自旋锁：**在等待唤醒的时候，经常会使用自旋（while(!cas())）的方式，不停地尝试获取锁，直到被其他线程获取成功

aqs的一个独占锁简单DEMO

private static class Sync extends AbstractQueuedSynchronizer {
    // 判断是否锁定状态
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }

    // 尝试获取资源，立即返回。成功则返回true，否则false。
    public boolean tryAcquire(int acquires) {
        assert acquires == 1; // 这里限定只能为1个量
        if (compareAndSetState(0, 1)) {//state为0才设置为1，不可重入！
            setExclusiveOwnerThread(Thread.currentThread());//设置为当前线程独占资源
            return true;
        }
        return false;
    }

    // 尝试释放资源，立即返回。成功则为true，否则false。
    protected boolean tryRelease(int releases) {
        assert releases == 1; // 限定为1个量
        if (getState() == 0)//既然来释放，那肯定就是已占有状态了。只是为了保险，多层判断！
            throw new IllegalMonitorStateException();
        setExclusiveOwnerThread(null);
        setState(0);//释放资源，放弃占有状态
        return true;
    }
}

aqs共享锁demo:

// 拷贝至 RocketMQ源码, 基于boolean的共享锁
public class BooleanMutex {

    private Sync sync;

    public BooleanMutex() {
        sync = new Sync();
        set(false);
    }

    public BooleanMutex(Boolean mutex) {
        sync = new Sync();
        set(mutex);
    }

    /**
     * 阻塞等待Boolean为true
     *
     * @throws InterruptedException
     */
    public void get() throws InterruptedException {
        sync.innerGet();
    }

    /**
     * 阻塞等待Boolean为true,允许设置超时时间
     *
     * @param timeout
     * @param unit
     * @throws InterruptedException
     * @throws TimeoutException
     */
    public void get(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
        sync.innerGet(unit.toNanos(timeout));
    }

    /**
     * 重新设置对应的Boolean mutex
     *
     * @param mutex
     */
    public void set(Boolean mutex) {
        if (mutex) {
            sync.innerSetTrue();
        } else {
            sync.innerSetFalse();
        }
    }

    public boolean state() {
        return sync.innerState();
    }

    /**
     * Synchronization control for BooleanMutex. Uses AQS sync state to
     * represent run status
     */
    private final class Sync extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = 2559471934544126329L;
        /**
         * State value representing that TRUE
         */
        private static final int TRUE = 1;
        /**
         * State value representing that FALSE
         */
        private static final int FALSE = 2;

        private boolean isTrue(int state) {
            return (state & TRUE) != 0;
        }

        /**
         * 实现AQS的接口，获取共享锁的判断
         */
        @Override
        protected int tryAcquireShared(int state) {
            // 如果为true，直接允许获取锁对象
            // 如果为false，进入阻塞队列，等待被唤醒
            return isTrue(getState()) ? 1 : -1;
        }

        /**
         * 实现AQS的接口，释放共享锁的判断
         */
        @Override
        protected boolean tryReleaseShared(int ignore) {
            // 始终返回true，代表可以release
            return true;
        }

        boolean innerState() {
            return isTrue(getState());
        }

        void innerGet() throws InterruptedException {
            acquireSharedInterruptibly(0);
        }

        void innerGet(long nanosTimeout) throws InterruptedException, TimeoutException {
            if (!tryAcquireSharedNanos(0, nanosTimeout)) throw new TimeoutException();
        }

        void innerSetTrue() {
            for (; ; ) {
                int s = getState();
                if (s == TRUE) {
                    return; // 直接退出
                }
                if (compareAndSetState(s, TRUE)) {// cas更新状态，避免并发更新true操作
                    releaseShared(0);// 释放一下锁对象，唤醒一下阻塞的Thread
                    return;
                }
            }
        }

        void innerSetFalse() {
            for (; ; ) {
                int s = getState();
                if (s == FALSE) {
                    return; // 直接退出
                }
                if (compareAndSetState(s, FALSE)) {// cas更新状态，避免并发更新false操作
                    return;
                }
            }
        }

    }

}

总结:

AQS分为独占锁和共享锁两种模式:

独占锁

执行**acquire(int arg)**时，只能有一个线程，多个线程的话会被加入到阻塞队列中同步执行

执行**release()**时唤醒下一个线程

tryAcquire(int arg)返回的是boolean值
共享锁

执行**acquireShared(int arg)**时，可以多个线程进行争抢

执行**releaseShared()**时如果成功，则把队列中所有的线程全部执行

**releaseShared()**完成后才返回

tryAcquireShared(int arg)返回的是int类型的值