关于java:后端面经JavaAQS详解

AQS 定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如罕用的 ReentrantLock。
简略来说，AQS 定义了一套框架，来实现同步类。

AQS 的核心思想是对于共享资源，保护一个双端队列来治理线程，队列中的线程顺次获取资源，获取不到的线程进入队列期待，直到资源开释，队列中的线程顺次获取资源。
AQS 的根本框架如图所示：

state 变量示意共享资源，通常是 int 类型。

拜访办法
state 类型用户无奈间接进行批改，而须要借助于 AQS 提供的办法进行批改，即getState()、setState()、compareAndSetState() 等。
拜访类型
AQS 定义了两种资源拜访类型:
- 独占（Exclusive）: 一个工夫点资源只能由一个线程占用；
- 共享（Share）: 一个工夫点资源能够被多个线程共用。

CLH 队列是一种基于逻辑队列非线程饥饿的自旋偏心锁，具体介绍可参考此篇博客。CLH 中每个节点都示意一个线程，处于头部的节点获取资源，而其余资源则期待。

节点构造
Node 类源码如下所示：

static final class Node {
 // 模式，分为共享与独占
 // 共享模式
 static final Node SHARED = new Node();
 // 独占模式
 static final Node EXCLUSIVE = null;        
 // 结点状态
 // CANCELLED，值为 1，示意以后的线程被勾销
 // SIGNAL，值为 -1，示意以后节点的后继节点蕴含的线程须要运行，也就是 unpark
 // CONDITION，值为 -2，示意以后节点在期待 condition，也就是在 condition 队列中
 // PROPAGATE，值为 -3，示意以后场景下后续的 acquireShared 可能得以执行
 // 值为 0，示意以后节点在 sync 队列中，期待着获取锁
 static final int CANCELLED =  1;
 static final int SIGNAL    = -1;
 static final int CONDITION = -2;
 static final int PROPAGATE = -3;        

 // 结点状态
 volatile int waitStatus;        
 // 前驱结点
 volatile Node prev;    
 // 后继结点
 volatile Node next;        
 // 结点所对应的线程
 volatile Thread thread;        
 // 下一个期待者
 Node nextWaiter;
 
 // 结点是否在共享模式下期待
 final boolean isShared() {return nextWaiter == SHARED;}
 
 // 获取前驱结点，若前驱结点为空，抛出异样
 final Node predecessor() throws NullPointerException {
  // 保留前驱结点
  Node p = prev; 
  if (p == null) // 前驱结点为空，抛出异样
      throw new NullPointerException();
  else // 前驱结点不为空，返回
      return p;
 }
 
 // 无参构造方法
 Node() {    // Used to establish initial head or SHARED marker}
 
 // 构造方法
  Node(Thread thread, Node mode) {    // Used by addWaiter
  this.nextWaiter = mode;
  this.thread = thread;
 }
 
 // 构造方法
 Node(Thread thread, int waitStatus) { // Used by Condition
  this.waitStatus = waitStatus;
  this.thread = thread;
 }
}

Node的办法和属性值如图所示：

![](https://cdn.jsdelivr.net/gh/cyl173/Imagebed/node 节点.png)

其中,

waitStatus示意以后节点在队列中的状态；
thread示意以后节点示意的线程；
prev和 next 别离示意以后节点的前驱节点和后继节点；
nextWaiter d 当存在 CONDTION 队列时，示意一个 condition 状态的后继节点。
waitStatus
结点的期待状态是一个整数值，具体的参数值和含意如下所示：
1–CANCELLED，示意节点获取锁的申请被勾销，此时节点不再申请资源；
0，是节点初始化的默认值；
-1–SIGNAL, 示意线程做好筹备，期待资源开释；
-2–CONDITION，示意节点在 condition 期待队列中，期待被唤醒而进入同步队列；
-3–PROPAGATE，以后线程处于共享模式下的时候会应用该字段。

AQS 提供一系列构造，作为一个残缺的模板，自定义的同步器只须要实现资源的获取和开释就能够 ，而不须要思考底层的队列批改、状态扭转等逻辑。
应用 AQS 实现一个自定义同步器，须要实现的办法：

isHeldExclusively()：该线程是否独占资源，在应用到 condition 的时候会实现这一办法；
tryAcquire(int)：独占模式获取资源的形式，胜利获取返回true，否则返回false;
tryRelease(int): 独占模式开释资源的形式，胜利获取返回true，否则返回false;
tryAcquireShared(int)：共享模式获取资源的形式，胜利获取返回true，否则返回false;
tryReleaseShared(int)：共享模式开释资源的形式，胜利获取返回true，否则返回false;

一般来说，一个同步器是资源独占模式或者资源共享模式的其中之一，因而 tryAcquire(int) 和tryAcquireShared(int)只须要实现一个即可，tryRelease(int)和 tryReleaseShared(int) 同理。
然而同步器也能够实现两种模式的资源获取和开释，从而实现独占和共享两种模式。

acquire(int)是获取源码局部的顶层入口，源码如下所示：

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

这段代码展示的资源获取流程如下：

tryAcquire()尝试间接去获取资源；获取胜利则间接返回
如果获取失败，则 addWaiter() 将该线程退出期待队列的尾部，并标记为独占模式；
acquireQueued()使线程阻塞在期待队列中获取资源，始终获取到资源后才返回。

简略总结就是：

获取资源；
失败就排队；
排队要期待。

从上文的形容可见重要的办法有三个：tryAquire()、addWaiter()、acquireQueued()。上面将一一剖析其源码：

tryAcquire(int)是获取资源的办法，源码如下所示：

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

该办法是一个空办法，须要自定义同步器实现，因而在应用 AQS 实现同步器时，须要重写该办法。这也是“自定义的同步器只须要实现资源的获取和开释就能够”的体现。

addWaiter(Node.EXCLUSIVE)是将线程退出期待队列的尾部，源码如下所示：

private Node addWaiter(Node mode) {
    // 以给定模式结构结点。mode 有两种：EXCLUSIVE（独占）和 SHARED（共享）//aquire()办法是独占模式，因而间接应用 Exclusive 参数。Node node = new Node(Thread.currentThread(), mode);

    // 尝试疾速形式间接放到队尾。Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }

    // 上一步失败则通过 enq 入队。enq(node);
    return node;
}

首先，应用模式将以后线程结构为一个节点，而后尝试将该节点放入队尾，如果胜利则返回，否则调用 enq(node) 将节点放入队尾，最终返回以后节点的地位指针。
其中，enq(node)办法是将节点退出队列的办法，源码如下所示：

private Node enq(final Node node) {for (;;) { // 有限循环，确保结点可能胜利入队列
        // 保留尾结点
        Node t = tail;
        if (t == null) { // 尾结点为空，即还没被初始化
            if (compareAndSetHead(new Node())) // 头节点为空，并设置头节点为新生成的结点
                tail = head; // 头节点与尾结点都指向同一个新生结点
        } else { // 尾结点不为空，即曾经被初始化过
            // 将 node 结点的 prev 域连贯到尾结点
            node.prev = t; 
            if (compareAndSetTail(t, node)) { // 比拟结点 t 是否为尾结点，若是则将尾结点设置为 node
                // 设置尾结点的 next 域为 node
                t.next = node; 
                return t; // 返回尾结点
            }
        }
    }
}

这部分源码是将线程阻塞在期待队列中，线程处于期待状态，直到获取到资源后才返回，源码如下所示：

// sync 队列中的结点在独占且疏忽中断的模式下获取(资源)
final boolean acquireQueued(final Node node, int arg) {
    // 标记
    boolean failed = true;
    try {
        // 中断标记
        boolean interrupted = false;
        for (;;) { // 有限循环
            // 获取 node 节点的前驱结点
            final Node p = node.predecessor(); 
            if (p == head && tryAcquire(arg)) { // 前驱为头节点并且胜利取得锁
                setHead(node); // 设置头节点
                p.next = null; // help GC
                failed = false; // 设置标记
                return interrupted; 
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())//
                //shouldParkAfterFailedAcquire 只有当该节点的前驱结点的状态为 SIGNAL 时，才能够对该结点所封装的线程进行 park 操作。否则，将不能进行 park 操作。//parkAndCheckInterrupt 首先执行 park 操作，即禁用以后线程，而后返回该线程是否曾经被中断
                interrupted = true;
        }
    } finally {if (failed)
            cancelAcquire(node);
    }
}

acquireQueued(Node node, int arg)办法的次要逻辑如下：

获取 node 节点的前驱结点, 判断前驱节点是不是头部节点 head，有没有胜利获取资源。
如果前驱结点是头部节点 head 并且获取了资源，阐明本人应该被唤醒，设置该节点为 head 节点期待下一个取得资源；
如果前驱节点不是头部节点或者没有获取资源，则判断是否须要 park 以后线程，
- 判断前驱节点状态是不是SIGNAL，是的话则 park 以后节点，否则不执行 park 操作；
park以后节点之后，以后节点进入期待状态，期待被其余节点 unpark 操作唤醒。而后反复此逻辑步骤。

release(int)是开释资源的顶层入口办法，源码如下所示：

public final boolean release(int arg) {if (tryRelease(arg)) { // 开释胜利
        // 保留头节点
        Node h = head; 
        if (h != null && h.waitStatus != 0) // 头节点不为空并且头节点状态不为 0
            unparkSuccessor(h); // 开释头节点的后继结点
        return true;
    }
    return false;
}

release(int)办法的次要逻辑如下：

尝试开释资源，如果开释胜利则返回true，否则返回false；
开释胜利之后，须要调用 unparkSuccessor(h) 唤醒后继节点。

上面介绍两个重要的源码函数：tryRelease(int)和unparkSuccessor(h)。

tryRelease(int)是开释资源的办法，源码如下所示：

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

这部分是须要自定义同步器本人实现的，要留神的是返回值须要为 boolean 类型，示意开释资源是否胜利。

unparkSuccessor(h)是唤醒后继节点的办法，源码如下所示：

private void unparkSuccessor(Node node) {
    // 这里，node 个别为以后线程所在的结点。int ws = node.waitStatus;
    if (ws < 0)// 置零以后线程所在的结点状态，容许失败。compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;// 找到下一个须要唤醒的结点 s
    if (s == null || s.waitStatus > 0) {// 如果为空或已勾销
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev) // 从后向前找。if (t.waitStatus <= 0)// 从这里能够看出，<= 0 的结点，都是还无效的结点。s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);// 唤醒
}

这部分次要是查找第一个还处于期待状态的节点，将其唤醒；
查找程序是从后往前找，这是因为 CLH 队列中的 prev 链是强统一的，从后往前找更加平安，而 next 链因为 addWaiter() 办法和 cancelAcquire() 办法的存在，不是强统一的，因而从前往后找可能会呈现问题。这部分的具体解释能够参考参考文献 -1

是应用共享模式获取共享资源的顶层入口办法，源码如下所示：

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

流程如下：

通过 tryAcquireShared(arg) 尝试获取资源，如果获取胜利则间接返回；
如果获取资源失败，则调用 doAcquireShared(arg) 将线程阻塞在期待队列中，直到被 unpark()/interrupt() 并胜利获取到资源才返回。

其中，tryAcquireShared(arg)是获取共享资源的办法，也是须要用户本人实现。

而 doAcquireShared(arg) 是将线程阻塞在期待队列中，直到获取到资源后才返回，具体流程和 acquireQueued() 办法相似，
源码如下所示：

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);
    }
}

releaseShared(int)是开释共享资源的顶层入口办法，源码如下所示：

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

流程如下：

应用 tryReleaseShared(arg) 尝试开释资源，如果开释胜利则返回 true，否则返回 false；
如果开释胜利，则调用 doReleaseShared() 唤醒后继节点。

上面介绍一下 doReleaseShared() 办法，源码如下所示：

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;
        }
        if (h == head)// head 发生变化
            break;
    }
}

Q：AQS 是接口吗？有哪些没有实现的办法？看过相干源码吗？

AQS 定义了一个实现同步类的框架，实现办法次要有 tryAquire 和tryRelease，示意独占模式的资源获取和开释，tryAquireShared和 tryReleaseShared 示意共享模式的资源获取和开释。
源码剖析如上文所述。

Java 并发之 AQS 详解
JUC 锁: 锁外围类 AQS 详解
从 ReentrantLock 的实现看 AQS 的原理及利用

关于java:后端面经JavaAQS详解

1. AQS 是什么？

2. AQS 核心思想

2.1 根本框架

2.1.1 资源 state

2.1.2 CLH 双向队列

2.2 AQS 模板

3. 源码剖析

3.1 acquire(int)

3.1.1 tryAcquire(int)

3.1.2 addWaiter(Node.EXCLUSIVE)

3.1.3 acquireQueued(Node node, int arg)

3.2 release(int)

3.2.1 tryRelease(int)

3.2.2 unparkSuccessor(h)

3.3 acquireShared(int)和 releaseShared(int)

3.3.1 acquireShared(int)

3.3.2 releaseShared(int)

4. 面试问题模仿

参考资料