网站建设有哪些家旅游网站建设初衷

引言

上篇文章讲解了CountDownLatch源码，底层是继承了AQS基类调用父类和重写父类方法实现的，本文将简介AQS源码和架构设计，帮助我们更深入理解多线程实战。

源码架构

1.  状态变量 state
AQS 使用一个 int 类型的变量 state 来表示同步状态。这个变量是 volatile 修饰的，保证了多线程之间的可见性。不同的同步器对 state 有不同的定义和使用方式，例如在 ReentrantLock 中，state 表示锁的重入次数；在 CountDownLatch 中，state 表示计数器的值。

private volatile int state;

2. 双向队列
AQS 内部维护了一个双向链表队列，用于存储等待获取锁的线程。这个队列是 CLH（Craig, Landin, and Hagersten）锁队列的变种。每个节点（Node）代表一个等待线程，包含线程引用、等待状态等信息。

static final class Node {// 共享模式static final Node SHARED = new Node();// 独占模式static final Node EXCLUSIVE = null;// 线程已取消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;// 指向下一个处于 CONDITION 状态的节点Node nextWaiter;...
}

而双向队列细分为条件队列和同步队列

同步队列

同步队列是 AQS 的核心队列，用于存放等待获取锁的线程节点。当线程尝试获取锁失败时，会被封装成节点加入到这个队列中等待。

在 AQS 类中有两个关键属性用于表示同步队列的头节点和尾节点：

private transient volatile Node head;
private transient volatile Node tail;

head 指向队列的头节点，tail 指向队列的尾节点，这两个属性都是 volatile 修饰的，保证了多线程环境下的可见性。

节点加入同步队列（addWaiter 方法）

private Node addWaiter(Node mode) {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;
}private Node enq(final Node node) {for (;;) {Node t = tail;if (t == null) { // 队列还未初始化if (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}
}

条件队列

条件队列用于实现线程的等待 - 通知机制，一个 AQS 可以有多个条件队列，每个 Condition 对象对应一个条件队列。

关键类 ConditionObject

ConditionObject 是 AQS 中实现条件队列的内部类，它包含一个指向条件队列头节点和尾节点的引用

public class ConditionObject implements Condition, java.io.Serializable {private transient Node firstWaiter;private transient Node lastWaiter;...
}

线程进入条件队列（await 方法）

public final void await() throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();Node node = addConditionWaiter();int savedState = fullyRelease(node);int interruptMode = 0;while (!isOnSyncQueue(node)) {LockSupport.park(this);if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)break;}if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;if (node.nextWaiter != null) // clean up if cancelledunlinkCancelledWaiters();if (interruptMode != 0)reportInterruptAfterWait(interruptMode);
}private Node addConditionWaiter() {Node t = lastWaiter;// 如果尾节点已取消，清除队列中所有已取消的节点if (t != null && t.waitStatus != Node.CONDITION) {unlinkCancelledWaiters();t = lastWaiter;}Node node = new Node(Thread.currentThread(), Node.CONDITION);if (t == null)firstWaiter = node;elset.nextWaiter = node;lastWaiter = node;return node;
}

唤醒条件队列中的线程

public final void signal() {if (!isHeldExclusively())throw new IllegalMonitorStateException();Node first = firstWaiter;if (first != null)doSignal(first);
}private void doSignal(Node first) {do {if ( (firstWaiter = first.nextWaiter) == null)lastWaiter = null;first.nextWaiter = null;} while (!transferForSignal(first) &&(first = firstWaiter) != null);
}final boolean transferForSignal(Node node) {// 将节点的等待状态从 CONDITION 改为 0if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))return false;// 将节点从条件队列转移到同步队列Node p = enq(node);int ws = p.waitStatus;if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))LockSupport.unpark(node.thread);return true;
}