一、AQS是什么？有什么作用？

概念：AQS(AbstractQueuedSynchronizer),直译为抽象队列同步器，是一种用来构建锁和同步器的框架。

作用：基于AQS构建同步器

• ReentrantLock
• Semaphore
• CountDownLatch
• ReentrantReadWriteLock
• SynchronusQueue
• FutureTask

优势：

• AQS解决了在实现同步器时涉及的大量细节问题，比如自定义标准同步状态、FIFO同步队列。
• 基于AQS构建同步器可以带来很多好处，不仅能够极大地减少实现工作，而且不必处理在多个位置上发生的竞争问题。

二、AQS核心

2.1 AQS核心思想

如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现，即将暂时获取不到锁的线程加入到队列中。如图：

Sync queue:同步队列，是一个双向列表，包括head节点和tail节点，head节点主要用作后续调度。

Condition queue:非必须，单项列表。当程序中存在condition时才会存在此列表

当一个线程需要获取锁时：

• 创建一个QNode，将其中的locked设置为true表示需要获取锁，myPred表示对其前驱节点的引用，每个节点都是加在队列尾部。
• 线程在其前驱节点locked字段上自旋，直到前驱节点释放锁（前驱节点的锁值 locked == false）,例如QNode_B一直自旋，当A释放锁了就将locked=false，B获取锁
• 当一个线程需要释放锁时，将当前节点的locked域设置为false

2.2 AQS设计思想

• AQS使用一个int成员变量表示同步状态
• 使用Node实现FIFO队列，可用于构建锁或其它同步装置
• AQS资源共享方式：独占Exclusive（独占锁模式）和共享Share（共享锁模式）

AQS它的所有子类中，要么实现并使用了它的独占功能的api，要么使用了共享锁的功能，而不会同时使用两套api，即便是最有名的子类ReentrantReadWriteLock也是通过两个内部类读锁和写锁分别实现了两套api来实现的

2.2.1 资源共享方式

2.2.1.1 EXCLUSIVE(独占)

概念：独占时锁表示线程通过互斥的模式占有使用锁，互斥即同一时间锁资源只能由同一个线程所持有。

2.2.1.2 SHARED(共享)

概念：线程以共享的模式等待锁

成员变量：

• waitStatus：该变量表示线程在队列中的状态（CANCELLED\SIGNAL\CONDITION\PROPAGATE）
• prev：变量类型为Node对象，表示该节点前一个Node节点（前驱）
• next：变量类型为Node对象，表示该节点后一个Node节点（后继）
• thread：变量类型为Thread对象，表示该节点代表的线程
• nextWaiter：变量类型为Node对象，表示等待condition条件的Node节点

AQS中Node常量含义（waitStatus）

• CANCELLED：waitStatus值为1时表示该线程节点已释放（超时、中断），获取锁的请求已经取消
• SIGNAL：waitStatus为-1时表示该线程的后续线程需要阻塞，即只要前置节点释放锁，就会通知标识为SIGNAL状态的后续节点的线程
• CONDITION：waitStatus为-2时，表示该线程在condition队列中阻塞（Condition使用），等待某个条件被满足
• PROPAGATE：waitStatus为-3时，表示该线程以及后续线程进行无条件传播（CountDownLatch中使用）共享模式下，PROPAGATE状态的线程处于可运行状态。

三、 AQS过程

线程首先尝试获取锁，如果失败将当前线程及等待状态等信息包装成一个node节点加入FIFO队列中，接着会不断的循环尝试获取锁，条件是当前节点为head的直接后继节点才会尝试。如果失败就会阻塞直到自己被唤醒。而当持有锁的线程释放锁的时候，会唤醒队列中的后继线程。

3.1 独占模式下AQS

概念：只允许一个线程获取同步状态，当这个线程还没有释放同步状态时，其它线程获取不了同步状态，只能加入到同步队列中进行等待。

明显我们可以将state初始值设置为0表示空闲。当一个线程获取到同步状态时，利用CAS操作对state加1，表示非空闲，那么其他线程就只能等待了释放同步状态时，不需要CAS操作，因为独占模式下只有一个线程能获取到同步状态。ReentrantLock、CyclicBarrieer正是基于此设计。

例如，ReentrantLock、state初始化为0，表示锁定状态，A线程lock()时，会调用tryAcquire()独占该锁并将state+1

独占模式下的AQS是不响应中断的，指的是加入到同步队列中的线程，如果因为中断而被唤醒的话，不会立即返回并抛出InterruptedException。而是再次去判断其前驱节点是否为head节点，决定是否争抢同步状态。如果其前驱节点不是head节点或者争抢同步状态失败，那么再次挂起。

3.1.1 独占模式下获取资源-acquire方法

作用：acquire以独占exclusive方式获取资源，如果获取到资源，线程直接返回否则进入等待队列知道获取到资源为止，且整个过程忽略中断的影响。

源码：

 public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

• 调用自定义同步器的tryAcquire()尝试直接获取资源，如果成功直接返回；
• 失败，调用addWaiter()将该线程加入等待队列尾部，标记为独占模式
• acquireQueued()使线程在等待队列中休息，有机会时（轮到自己，会被unpark()）尝试获取资源。获取到资源后才返回，如果整个等待过程被中断，返回true，否则返回false
• 如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfinterrupt()，将中断补上。

3.1.2 独占模式获取资源-tryAcquire方法

作用：tryAcquire尝试通过独占的方式获取资源，如果获取成功直接返回true，否则直接返回false。具体实现由自定义的AQS同步器实现。

源码：

 protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

3.1.3 独占模式获取资源-addWaiter方法

作用：根据不同模式（Node.EXCLUSIVE互斥模式、Node.SHARED共享模式）创建节点并以CAS的方式将当前线程节点加入到不为空的等待队列的末尾（通过compareAndSetTail()方法）。如果队列为空，通过enq(node)方法初始化一个等待队列，并返回当前节点。

源码：

/**
* 参数
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* 返回值
* @return the new node
*/
private Node addWaiter(Node mode) {
    //将当前线程以指定的模式创建节点node
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    // 获取当前同队列的尾节点
    Node pred = tail;
    //队列不为空，将新的node加入等待队列中
    if (pred != null) {
        node.prev = pred;
         //CAS方式将当前节点尾插入队列中
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //当队列为empty或者CAS失败时会调用enq方法处理
    enq(node);
    return node;
}

在该过程中，队列为empty时使用enq(node)处理，将当前节点插入等待队列，如果队列为空则初始化当前队。所有操作都是CAS自旋方式进行，直到成功加入队尾为止。

 private Node enq(final Node node) {
        //不断自旋
        for (;;) {
            Node t = tail;
            //当前队列为empty
            if (t == null) { // Must initialize
             //完成队列初始化操作，头结点中不放数据，只是作为起始标记，lazy-load，在第一次用的时候new
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                //不断将当前节点使用CAS尾插入队列中直到成功为止
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

3.1.4 独占模式获取资源-acquireQueued方法

作用：作用于已在队列中的线程以独占且不间断模式获取state状态直到获取锁后返回。

源码：

final boolean acquireQueued(final Node node, int arg) {
  //是否已获取锁的标志，默认为true 即为尚未
  boolean failed = true;
  try {
      //等待中是否被中断过的标记
      boolean interrupted = false;
      for (;;) {
          //获取前节点
          final Node p = node.predecessor();
          //如果当前节点已经成为头结点，尝试获取锁（tryAcquire）成功，然后返回
          if (p == head && tryAcquire(arg)) {
              setHead(node);
              p.next = null; // help GC
              failed = false;
              return interrupted;
          }
          //shouldParkAfterFailedAcquire根据对当前节点的前一个节点的状态进行判断，对当前节点做出不同的操作
          //parkAndCheckInterrupt让线程进入等待状态，并检查当前线程是否被可以被中断
          if (shouldParkAfterFailedAcquire(p, node) &&
              parkAndCheckInterrupt())
              interrupted = true;
      }
  } finally {
      //将当前节点设置为取消状态；取消状态设置为1
      if (failed)
          cancelAcquire(node);
  }
}

• 节点node进入队列尾部后，检查状态；
• 调用park()进入waiting状态，等待unpark()或interrupt()唤醒；
• 被唤醒后，是否获取到锁。如果获取到，head指向当前节点，并返回从入队到获取锁的整个过程中是否被中断过；如果没获取到，继续流程1

3.1.5 独占模式释放资源-release方法

作用：release方法是独占exclusive模式下线程释放共享资源的锁。它会调用tryRelease()释放同步资源，如果全部释放了同步状态为空闲（state=0），当同步状态为空闲时，它会唤醒等待队列里的其它线程来获取资源。

源码：

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

3.1.6 独占模式释放资源-tryRelease方法

作用：tryRelease跟tryAcquire一样实现都是由自定义定时器以独占exclusive模式实现的。因为其是独占模式，不需要考虑线程安全问题去释放共享资源，直接减掉相应量的资源即可（state=arg）。而且tryRelease()返回值代表着该线程是否已经完成资源的释放，因此在自定义同步器的tryRelease（）时，需要明确该条件，当已经彻底释放资源，要返回true，否则返回false。

源码：

 protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

ReentrantReadWriteLock实现：

protected final boolean tryRelease(int releases) {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        //减掉相应量的资源(state-=arg)
        int nextc = getState() - releases;
        //是否完全释放资源
        boolean free = exclusiveCount(nextc) == 0;
        if (free)
            setExclusiveOwnerThread(null);
        setState(nextc);
        return free;
    }

3.1.7 独占模式释放资源-unparkSuccessor

作用：unparkSuccessor通过unpark()唤醒等待队列中最前驱的那个未放弃线程，此线程并不一定是当前节点的next节点，而是下一个可以用来唤醒的线程，如果这个节点存在，调用unpark()方法唤醒。

源码：

 private void unparkSuccessor(Node node) {
    //当前线程所在的结点node
    int ws = node.waitStatus;
    //置零当前线程所在的结点状态，允许失败
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    //找到下一个需要唤醒的结点
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从后向前找
        for (Node t = tail; t != null && t != node; t = t.prev)
            //从这里可以看出，<=0的结点，都是还有效的结点
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
         //唤醒
        LockSupport.unpark(s.thread);
}

3.2 共享模式下的AQS

概念：允许多个线程同时获取到同步状态，共享模式下的AQS也是不响应中断的。

很明显，我们可以将state初始值设为N(N > 0),表示空闲。每当一个线程获取到同步状态时，利用CAS操作使state减1，直到0表示非空闲。其它线程就只能加入到同步队列进行等待。释放同步状态时，需要CAS操作，因为共享模式下有多个线程能获取到同步状态。

例如：CountDownLatch任务分为N个子线程去执行，同步状态state也初始化为N(注意N需与线程个数一致)

3.2.1 共享模式获取资源-acquireShared方法

作用：共享模式下线程获取共享资源的顶层入口。它会获取指定量的资源，获取成功直接返回，失败则进入等待队列，直到获取到资源为止，整个过程忽略中断。

源码：

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

• 通过tryAccquireShared()尝试获取资源，成功直接返回
• 失败通过doAcquireShared()中的park()进入等待队列，直到被unpark()/interrupt()并成功获取到资源才返回

3.2.2 共享模式获取资源-tryAcquireShared方法

作用：跟独占模式获取资源方法一样实现都是由自定义同步器实现。但AQS规范中已定义好tryAcqureShared的返回值。

源码：

 protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

• 负值代表获取失败；
• 0代表获取成功，但没有剩余资源
• 正数表示获取成功，还有剩余资源，其它线程还可以获取

3.2.3 共享模式获取资源-doAcquireShared方法

作用：用于将当前线程加入等待队列尾部休息，直到其它线程释放资源唤醒自己，自己成功获取到相应量资源后才返回。

源码：

private void doAcquireShared(int arg) {
    //加入队列尾部
    final Node node = addWaiter(Node.SHARED);
    //是否成功标志
    boolean failed = true;
    try {
        //等待过程中是否被中断过的标志
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();//获取前驱节点
            if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
                int r = tryAcquireShared(arg);//尝试获取资源
                if (r >= 0) {//成功
                    setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
                    p.next = null; // help GC
                    if (interrupted)//如果等待过程中被打断过，此时将中断补上。
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            
            //判断状态，队列寻找一个适合位置，进入waiting状态，等着被unpark()或interrupt()
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }   
}

3.2.4 共享模式释放资源-releaseShared方法

作用：用于共享模式下线程释放共享资源，释放指定量的资源。如果成功释放且允许唤醒等待线程，它会唤醒等待队列里的其它线程来获取资源。

源码：

public final boolean releaseShared(int arg) {
    //尝试释放资源
    if (tryReleaseShared(arg)) {
        //唤醒后继结点
        doReleaseShared();
        return true;
    }
    return false;
}

独占模式下的tryRelease()在完全释放掉资源（state=0）后，才会返回true去唤醒其他线程，这主要是基于独占下可重入的考量；而共享模式下的releaseShared()则没有这种要求，共享模式实质就是控制一定量的线程并发执行，那么拥有资源的线程在释放掉部分资源时就可以唤醒后继等待结点。
https://www.cnblogs.com/waterystone/p/4920797.html

3.2.5共享模式释放资源-doReleaseShared方法

作用：用于唤醒后继节点线程，当state为正数，获取剩余共享资源；当state=0时去获取共享资源

源码：

private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;
                    //唤醒后继
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;
        }
        // head发生变化
        if (h == head)
            break;
    }
}