@ -108,6 +108,431 @@ ReentrantLock、ReentrantReadWriteLock 都是基于 AbstractQueuedSynchronizer (
## AQS框架
### 基础
AbstractQueuedSynchronizer抽象同步队列简称AQS， ，
AQS定义了一套多线程访问共享资源的同步模板， ， ， （ ） ， ， ，
三部分组成：`state同步状态`、`Node组成的CLH队列`、`ConditionObject条件变量`（ ）
**状态**
- `getState()` ：返回同步状态
- `setState(int newState)` ：设置同步状态
- `compareAndSetState(int expect, int update)` ：
- `isHeldExclusively()` ：当前线程是否持有资源
**独占资源（不响应线程中断）**
- `tryAcquire(int arg)` ：独占式获取资源，子类实现
- `acquire(int arg)` ：独占式获取资源模板
- `tryRelease(int arg)` ：独占式释放资源，子类实现
- `release(int arg)` ：独占式释放资源模板
**共享资源（不响应线程中断）**
- `tryAcquireShared(int arg)` ： ， ， ，
- `acquireShared(int arg)` ：共享形获取资源模板
- `tryReleaseShared(int arg)` ：共享式释放资源，子类实现
- `releaseShared(int arg)` ：共享式释放资源模板
### 同步状态
在AQS中维护了一个同步状态变量state， ， ， ， ， ， ， ， ，
- ReentrantLock的state用来表示是否有锁资源
- ReentrantReadWriteLock的state高16位代表读锁状态，
- Semaphore的state用来表示可用信号的个数
- CountDownLatch的state用来表示计数器的值
### CLH队列
CLH是AQS内部维护的FIFO（ ） （ ） ， ， ， ， ， ， ， ：
- 先进先出保证了公平性
- 非阻塞的队列， ，
- 采用了自旋锁思想，
### Node内部类
`Node` 是`AQS`的内部类，每个等待资源的线程都会封装成`Node`节点组成`CLH`队列、等待队列，所以说`Node`是非常重要的部分，理解它是理解`AQS`的第一步。
**waitStatus等待状态如下**
**nextWaiter特殊标记**
- ** `Node` 在`CLH`队列时，`nextWaiter`表示共享式或独占式标记**
- ** `Node` 在条件队列时，`nextWaiter`表示下个`Node`节点指针**
### 流程概述
线程获取资源失败，封装成`Node`节点从`C L H`队列尾部入队并阻塞线程，某线程释放资源时会把`C L H`队列首部`Node`节点关联的线程唤醒（**此处的首部是指第二个节点，后面会细说**），再次获取资源。
### 入队
获取资源失败的线程需要封装成`Node`节点，接着尾部入队，在`AQS`中提供`addWaiter`函数完成`Node`节点的创建与入队。
```java
/**
* @description: Node节点入队-CLH队列
* @param mode 标记Node.EXCLUSIVE独占式 or Node.SHARED共享式
*/
private Node addWaiter(Node mode) {
// 根据当前线程创建节点，
Node node = new Node(Thread.currentThread(), mode);
// 获取尾节点
Node pred = tail;
if (pred != null) {
// 如果尾节点不等于null，
node.prev = pred;
// 通过CAS把尾节点指向当前节点
if (compareAndSetTail(pred, node)) {
// 之前尾节点的下个节点指向当前节点
pred.next = node;
return node;
}
}
// 如果添加失败或队列不存在，
enq(node);
return node;
}
```
添加节点的时候，如果从`CLH`队列已经存在，通过`CAS`快速将当前节点添加到队列尾部，如果添加失败或队列不存在，则指向`enq`函数自旋入队。
```java
/**
* @description: 自旋cas入队
* @param node 节点
*/
private Node enq(final Node node) {
for (;;) { //循环
//获取尾节点
Node t = tail;
if (t == null) {
//如果尾节点为空， ，
if (compareAndSetHead(new Node()))
//cas成功，
tail = head;
} else {
//当前节点的前驱节点设指向之前尾节点
node.prev = t;
//cas设置把尾节点指向当前节点
if (compareAndSetTail(t, node)) {
//cas成功，
t.next = node;
return t;
}
}
}
}
```
通过自旋`CAS`尝试往队列尾部插入节点，直到成功，自旋过程如果发现`CLH`队列不存在时会初始化`CLH`队列，入队过程流程如下图：
第一次循环
- 刚开始C L H队列不存在，
- 要初始化C L H队列， ，
第二次循环
- 当前线程节点的前驱节点指向尾部节点（哨兵节点）
- 设置当前线程节点为尾部，
- 前尾部节点的后驱节点指向当前线程节点（当前尾部节点）
最后结合addWaiter与enq函数的入队流程图如下
### 出队
`CLH` 队列中的节点都是获取资源失败的线程节点，当持有资源的线程释放资源时，会将`head.next`指向的线程节点唤醒（**`CLH`队列的第二个节点**），如果唤醒的线程节点获取资源成功，线程节点清空信息设置为头部节点（**新哨兵节点**），原头部节点出队（**原哨兵节点**）
```java
//1.获取前驱节点
final Node p = node.predecessor();
//如果前驱节点是首节点，获取资源（子类实现）
if (p == head & & tryAcquire(arg)) {
//2.获取资源成功，设置当前节点为头节点，清空当前节点的信息，把当前节点变成哨兵节点
setHead(node);
//3.原来首节点下个节点指向为null
p.next = null; // help GC
//4.非异常状态，
failed = false;
//5.返回线程中断状态
return interrupted;
}
private void setHead(Node node) {
//节点设置为头部
head = node;
//清空线程
node.thread = null;
//清空前驱节点
node.prev = null;
}
```
只需要关注`1~3`步骤即可，过程非常简单，假设获取资源成功，更换头部节点，并把头部节点的信息清除变成哨兵节点，注意这个过程是不需要使用`CAS`来保证，因为只有一个线程能够成功获取到资源。
### 条件变量
Object的wait、notify函数是配合Synchronized锁实现线程间同步协作的功能， ， ， ，
如上图所示， ， ， ， ， ， ，
当某个线程执行了ConditionObject的await函数， ， ， ， ，
### 模板方法
`AQS` 采用了模板方法设计模式，提供了两类模板，一类是独占式模板，另一类是共享形模式，对应的模板函数如下
- 独占式
- ** `acquire` 获取资源**
- ** `release` 释放资源**
- 共享式
- ** `acquireShared` 获取资源**
- ** `releaseShared` 释放资源**
#### 独占式获取资源
`acquire` 是个模板函数，模板流程就是线程获取共享资源，如果获取资源成功，线程直接返回，否则进入`CLH`队列，直到获取资源成功为止，且整个过程忽略中断的影响，`acquire`函数代码如下
- 执行tryAcquire函数， ， ， ，
- 执行addWaiter函数（ ） ， ，
- 执行acquireQueued函数，
- 如果acquireQueued函数中获取资源成功， ，
`acquire` 函数的大致流程都清楚了，下面来分析下`acquireQueued`函数，线程封装成节点后，是如何自旋阻塞等待获取资源的，代码如下：
```java
/**
* @description: 自旋机制等待获取资源
* @param node
* @param arg
* @return: boolean
*/
final boolean acquireQueued(final Node node, int arg) {
//异常状态，默认是
boolean failed = true;
try {
//该线程是否中断过，默认否
boolean interrupted = false;
for (;;) {//自旋
//获取前驱节点
final Node p = node.predecessor();
//如果前驱节点是首节点，获取资源（子类实现）
if (p == head & & tryAcquire(arg)) {
//获取资源成功，设置当前节点为头节点，清空当前节点的信息，把当前节点变成哨兵节点
setHead(node);
//原来首节点下个节点指向为null
p.next = null; // help GC
//非异常状态，
failed = false;
//返回线程中断状态
return interrupted;
}
/**
* 如果前驱节点不是首节点， ，
* 1.如果前驱节点的等待状态是SIGNAL， ， ，
* 2.如果前驱节点的等大状态是CANCELLED， （ ）
* 3.以上两者都不符合， ，
*/
if (shouldParkAfterFailedAcquire(p, node) & &
//使用LockSupport类的静态方法park挂起当前线程， ， ，
parkAndCheckInterrupt())
//该线程被中断过
interrupted = true;
}
} finally {
// 尝试获取资源失败并执行异常，取消请求，将当前节点从队列中移除
if (failed)
cancelAcquire(node);
}
}
```
一图胜千言，核心流程图如下:
#### 独占式释放资源
有获取资源，自然就少不了释放资源，`A Q S`中提供了`release`模板函数来释放资源，模板流程就是线程释放资源成功，唤醒`CLH`队列的第二个线程节点（**首节点的下个节点**），代码如下
```java
/**
* @description: 独占式-释放资源模板函数
* @param arg
* @return: boolean
*/
public final boolean release(int arg) {
if (tryRelease(arg)) {//释放资源成功，
//获取头部线程节点
Node h = head;
if (h != null & & h.waitStatus != 0) //头部线程节点不为null，
//唤醒CHL队列第二个线程节点
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
//获取节点等待状态
int ws = node.waitStatus;
if (ws < 0 )
//cas更新节点状态为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)
if (t.waitStatus < = 0)
s = t;
}
if (s != null)
//唤醒线程节点
LockSupport.unpark(s.thread);
}
}
```
`release` 逻辑非常简单，流程图如下：
#### 共享式获取资源
`acquireShared` 是个模板函数，模板流程就是线程获取共享资源，如果获取到资源，线程直接返回，否则进入`CLH`队列，直到获取到资源为止，且整个过程忽略中断的影响，`acquireShared`函数代码如下
```java
/**
* @description: 共享式-获取资源模板函数
* @param arg
* @return: void
*/
public final void acquireShared(int arg) {
/**
* 1.负数表示失败
* 2.0表示成功，但没有剩余可用资源
* 3.正数表示成功且有剩余资源
*/
if (tryAcquireShared(arg) < 0 ) / / 获 取 资 源 失 败 ， tryAcquireShared 子 类 实 现
//自旋阻塞等待获取资源
doAcquireShared(arg);
}
```
`doAcquireShared` 函数与独占式的`acquireQueued`函数逻辑基本一致，唯一的区别就是下图红框部分
- ** 节点的标记是共享式**
- ** 获取资源成功，还会唤醒后续资源，因为资源数可能`>0`，代表还有资源可获取，所以需要做后续线程节点的唤醒**
#### 共享式释放资源
`AQS` 中提供了`releaseShared`模板函数来释放资源， ， （
```java
/**
* @description: 共享式-释放资源模板函数
* @param arg
* @return: boolean
*/
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {//释放资源成功，
//唤醒后继节点
doReleaseShared();
return true;
}
return false;
}
private void doReleaseShared() {
for (;;) {
//获取头节点
Node h = head;
if (h != null & & h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {//如果头节点等待状态为SIGNAL
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//更新头节点等待状态为0
continue; // loop to recheck cases
//唤醒头节点下个线程节点
unparkSuccessor(h);
}
//如果后继节点暂时不需要被唤醒，
else if (ws == 0 & &
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
if (h == head)
break;
}
}
```
与独占式释放资源区别不大，都是唤醒头节点的下个节点。
**什么是AQS？
`AQS` 的全称是 `AbstractQueuedSynchronizer` ，即`抽象队列同步器`。是Java并发工具的基础， ， （ ） （ ） ， ， ，
ruyu.li
3 years ago
