016：AQS节点取消机制深度解析：CANCELLED状态与并发安全清理引言

---

🥂(❁´◡`❁)您的点赞👍➕评论📝➕收藏⭐➕关注👀是作者创作的最大动力🤞

💖📕🎉🔥 支持我：点赞👍+收藏⭐️+留言📝+关注👀欢迎留言讨论

🔥🔥🔥（源码获取 + 调试运行 + 问题答疑）🔥🔥🔥  有兴趣可以联系我

🔥🔥🔥  文末有往期免费源码，直接领取获取（无删减，无套路）

我们常常在当下感到时间慢，觉得未来遥远，但一旦回头看，时间已经悄然流逝。对于未来，尽管如此，也应该保持一种从容的态度，相信未来仍有许多可能性等待着我们。

🔥🔥🔥(免费，无删减，无套路)：java swing管理系统源码 程序 代码 图形界面（11套）」
链接：https://pan.quark.cn/s/784a0d377810
提取码：
🔥🔥🔥(免费，无删减，无套路)： Python源代码+开发文档说明（23套）」
链接：https://pan.quark.cn/s/1d351abbd11c
提取码：

🔥🔥🔥(免费，无删减，无套路)：计算机专业精选源码+论文（26套）」
链接：https://pan.quark.cn/s/8682a41d0097
提取码：
🔥🔥🔥(免费，无删减，无套路)：Java web项目源码整合开发ssm（30套）
链接：https://pan.quark.cn/s/1c6e0826cbfd
提取码：

🔥🔥🔥(无删减，无套路)：「在线考试系统源码（含搭建教程）」

链接：https://pan.quark.cn/s/96c4f00fdb43
提取码：

---

在AQS的同步队列中，节点的生命周期管理是一个复杂而精妙的过程。其中，节点的取消状态（CANCELLED）处理尤为关键，它直接关系到整个同步队列的完整性和性能。本文将深入探讨节点在什么情况下会被标记为CANCELLED状态，详细解析cancelAcquire方法的实现原理，并揭示节点从队列中安全"剔除"的并发安全机制。

节点取消的触发场景

节点被标记为CANCELLED状态通常发生在以下几种情况：

1. 获取锁超时

当使用带超时参数的获取锁方法（如tryAcquireNanos）时，如果在指定时间内未能成功获取锁，节点会被取消。

 public final boolean tryAcquireNanos(int arg, long nanosTimeout) {
     if (!tryAcquire(arg)) {
         // 超时逻辑
         if (nanosTimeout <= 0L)
             return false;
         // ... 超时检测
         if (Thread.interrupted())
             throw new InterruptedException();
     }
     return true;
 }

2. 线程被中断

当线程在等待过程中被中断，且该锁支持中断响应时，节点会被取消。

 private void doAcquireInterruptibly(int arg) throws InterruptedException {
     final Node node = addWaiter(Node.EXCLUSIVE);
     try {
         for (;;) {
             final Node p = node.predecessor();
             if (p == head && tryAcquire(arg)) {
                 setHead(node);
                 p.next = null;
                 return;
             }
             if (shouldParkAfterFailedAcquire(p, node) &&
                 parkAndCheckInterrupt())
                 throw new InterruptedException(); // 中断时抛出异常
         }
     } catch (Throwable t) {
         cancelAcquire(node); // 最终调用cancelAcquire
         throw t;
     }
 }

3. 获取锁过程中发生异常

在获取锁的自旋过程中发生异常，也会触发节点取消。

cancelAcquire方法深度解析

cancelAcquire方法是节点取消的核心逻辑，它负责将节点状态标记为CANCELLED，并处理节点从队列中的移除。

 private void cancelAcquire(Node node) {
     if (node == null)
         return;
 ​
     node.thread = null;
 ​
     // 跳过已取消的前驱节点
     Node pred = node.prev;
     while (pred.waitStatus > 0)
         node.prev = pred = pred.prev;
 ​
     // 获取前驱的后继节点（用于CAS操作）
     Node predNext = pred.next;
 ​
     // 将节点状态设置为CANCELLED
     node.waitStatus = Node.CANCELLED;
 ​
     // 如果节点是尾节点，直接CAS更新tail
     if (node == tail && compareAndSetTail(node, pred)) {
         compareAndSetNext(pred, predNext, null);
     } else {
         // 如果后继节点需要信号
         if (pred != head &&
             ((ws = pred.waitStatus) == Node.SIGNAL ||
              (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
             pred.thread != null) {
             Node next = node.next;
             if (next != null && next.waitStatus <= 0)
                 compareAndSetNext(pred, predNext, next);
         } else {
             unparkSuccessor(node);
         }
 ​
         node.next = node; // 帮助GC
     }
 }

关键步骤分析

1. 跳过已取消的前驱节点

 Node pred = node.prev;
 while (pred.waitStatus > 0)
     node.prev = pred = pred.prev;

这个循环的作用是跳过所有已取消的前驱节点，找到第一个未取消的有效前驱节点。这是保证链表完整性的重要步骤。

为什么需要这个操作？ 因为可能有多个连续的节点都被取消了，我们需要找到真正有效的"责任链"节点。

2. 状态标记与尾节点处理

 node.waitStatus = Node.CANCELLED;
 ​
 if (node == tail && compareAndSetTail(node, pred)) {
     compareAndSetNext(pred, predNext, null);
 }

如果取消的节点正好是尾节点，处理相对简单：直接通过CAS更新tail指针，并将前驱节点的next置为null。

3. 中间节点的复杂处理

对于队列中间的节点，处理逻辑更为复杂：

 if (pred != head &&
     ((ws = pred.waitStatus) == Node.SIGNAL ||
      (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
     pred.thread != null) {
     Node next = node.next;
     if (next != null && next.waitStatus <= 0)
         compareAndSetNext(pred, predNext, next);
 } else {
     unparkSuccessor(node);
 }

这段代码的核心思想是：确保取消节点的前驱节点能够正确地连接到取消节点的后继节点。

延迟清理的设计哲学

为什么不是立即完全移除？

在cancelAcquire方法中，我们注意到节点并不是立即从链表中完全移除的。这种设计有几个重要原因：

1. 并发安全考虑

在并发环境下，完全移除一个节点需要同时修改前驱节点的next指针和后继节点的prev指针。如果这两个操作不能原子性地完成，可能会导致链表状态不一致。

2. 责任链的延续

AQS的同步队列基于"责任链"模式：每个节点都有责任唤醒或通知其后继节点。如果立即完全移除节点，可能会破坏这种责任传递机制。

3. 性能优化

完全移除节点需要更多的CAS操作，在并发环境下会增加竞争。延迟清理可以将清理工作分散到多个线程中，提高整体吞吐量。

后续清理机制

被取消的节点最终会在以下场景中被完全清理：

1. shouldParkAfterFailedAcquire方法

这是最主要的清理时机：

 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
     int ws = pred.waitStatus;
     if (ws == Node.SIGNAL)
         return true;
     if (ws > 0) {
         do {
             node.prev = pred = pred.prev;
         } while (pred.waitStatus > 0);
         pred.next = node;
     } else {
         compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
     }
     return false;
 }

当后续节点在获取锁失败时，会调用此方法。如果发现前驱节点被取消，它会跳过所有已取消的节点，重新建立链表连接。

2. 其他入队和出队操作

在节点入队、出队等其他操作中，也会顺带清理遇到的已取消节点。

并发安全性保障

指针操作的顺序性

AQS在节点取消过程中严格遵守特定的指针操作顺序：

1. 先设置prev指针

2. 然后设置状态

3. 最后处理next指针

这种顺序确保了即使并发操作发生时，链表遍历仍然能够正确进行。

CAS操作的原子性

所有对共享变量的修改都通过CAS操作保证原子性：

• compareAndSetTail：更新尾指针

• compareAndSetWaitStatus：更新节点状态

• compareAndSetNext：更新next指针

内存可见性

通过volatile变量和CAS操作的内存屏障效应，保证了所有线程都能看到一致的内存状态。

实际应用中的影响

性能考虑

节点取消机制对性能有重要影响：

1. 内存占用：已取消的节点不会立即被回收，短期内会增加内存占用

2. 遍历开销：链表中的已取消节点会增加遍历长度

3. GC压力：延迟清理可能导致GC压力集中在某些时刻

调试与监控

理解节点取消机制有助于我们：

1. 诊断死锁：通过分析节点状态找出问题所在

2. 性能优化：识别过多的节点取消，优化锁竞争

3. 系统监控：监控队列长度和取消节点比例

总结

AQS的节点取消机制是一个精心设计的并发安全方案。它通过CANCELLED状态标记、延迟清理策略和并发安全的指针操作，在保证正确性的同时兼顾了性能。

理解这一机制不仅有助于我们更好地使用Java并发工具，更能提升我们在设计高并发系统时的架构能力。当我们面对复杂的并发场景时，AQS中这些经过实践检验的设计模式，为我们提供了宝贵的参考和借鉴。

往期免费源码对应视频：

免费获取--SpringBoot+Vue宠物商城网站系统

🥂(❁´◡`❁)您的点赞👍➕评论📝➕收藏⭐➕关注👀是作者创作的最大动力🤞

💖📕🎉🔥 支持我：点赞👍+收藏⭐️+留言📝+关注👀欢迎留言讨论

🔥🔥🔥（源码 + 调试运行 + 问题答疑）

🔥🔥🔥  有兴趣可以联系我

💖学习知识需费心，
📕整理归纳更费神。
🎉源码免费人人喜，
🔥码农福利等你领！

💖常来我家多看看，
📕网址：扣棣编程，
🎉感谢支持常陪伴，
🔥点赞关注别忘记！

💖山高路远坑又深，
📕大军纵横任驰奔，
🎉谁敢横刀立马行？
🔥唯有点赞+关注成！

⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇点击此处获取源码⬇⬇⬇⬇⬇⬇⬇⬇⬇