image.png

1、非公平锁实现原理

加锁解锁流程 先从构造器开始看，默认为非公平锁实现 

  1. public ReentrantLock() {
  2.     sync = new NonfairSync();
  3. }

NonfairSync 继承自 AQS
没有竞争时
image.png
第一个竞争出现时
image.png
Thread-1 执行了

  1. CAS 尝试将 state 由 0 改为 1，结果失败
  2. 进入 tryAcquire 逻辑，这时 state 已经是1，结果仍然失败
  3. 接下来进入 addWaiter 逻辑，构造 Node 队列
    图中黄色三角表示该 Node 的 waitStatus 状态，其中 0 为默认正常状态
    Node 的创建是懒惰的
    其中第一个 Node 称为 Dummy（哑元）或哨兵，用来占位，并不关联线程

image.png
当前线程进入 acquireQueued 逻辑

  1. acquireQueued 会在一个死循环中不断尝试获得锁，失败后进入 park 阻塞
  2. 如果自己是紧邻着 head（排第二位），那么再次 tryAcquire 尝试获取锁，当然这时 state 仍为 1，失败
  3. 进入 shouldParkAfterFailedAcquire 逻辑，将前驱 node，即 head 的 waitStatus 改为 -1，这次返回 false
  4. shouldParkAfterFailedAcquire 执行完毕回到 acquireQueued ，再次 tryAcquire 尝试获取锁，当然这时 state 仍为 1，失败
  5. 当再次进入 shouldParkAfterFailedAcquire 时，这时因为其前驱 node 的 waitStatus 已经是 -1，这次返回 true
  6. 进入 parkAndCheckInterrupt， Thread-1 park（灰色表示）

image.png
image.png
image.png
Thread-0 释放锁，进入 tryRelease 流程，如果成功

  • 设置 exclusiveOwnerThread 为 null
  • state = 0

image.png
当前队列不为 null，并且 head 的 waitStatus = -1，进入 unparkSuccessor 流程
找到队列中离 head 最近的一个 Node（没取消的），unpark 恢复其运行，本例中即为 Thread-1
回到 Thread-1 的 acquireQueued 流程
image.png
如果加锁成功（没有竞争），会设置

  • exclusiveOwnerThread 为 Thread-1，state = 1
  • head 指向刚刚 Thread-1 所在的 Node，该 Node 清空 Thread

  • 原本的 head 因为从链表断开，而可被垃圾回收

    如果这时候有其它线程来竞争（非公平的体现），例如这时有 Thread-4 来了
    image.png
    如果不巧又被 Thread-4 占了先

  • Thread-4 被设置为 exclusiveOwnerThread，state = 1

  • Thread-1 再次进入 acquireQueued 流程，获取锁失败，重新进入 park 阻塞

1、 加锁源码

  1. // Sync 继承自 AQS
  2. static final class NonfairSync extends Sync {
  3.     private static final long serialVersionUID = 7316153563782823691L;
  5.     // 加锁实现
  6.     final void lock() {
  7.         // 首先用 cas 尝试（仅尝试一次）将 state 从 0 改为 1, 如果成功表示获得了独占锁
  8.         if (compareAndSetState(0, 1))
  9.             setExclusiveOwnerThread(Thread.currentThread());
  10.         else
  11.             // 如果尝试失败，进入 ㈠
  12.             acquire(1);
  13.     }
  15.     // ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
  16.     public final void acquire(int arg) {
  17.         // ㈡ tryAcquire
  18.         if (
  19.             !tryAcquire(arg) &&
  20.             // 当 tryAcquire 返回为 false 时, 先调用 addWaiter ㈣, 接着 acquireQueued ㈤
  21.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
  22.         ) {
  23.             selfInterrupt();
  24.         }
  25.     }
  27.     // ㈡ 进入 ㈢
  28.     protected final boolean tryAcquire(int acquires) {
  29.         return nonfairTryAcquire(acquires);
  30.     }
  32.     // ㈢ Sync 继承过来的方法, 方便阅读, 放在此处
  33.     final boolean nonfairTryAcquire(int acquires) {
  34.         final Thread current = Thread.currentThread();
  35.         int c = getState();
  36.         // 如果还没有获得锁
  37.         if (c == 0) {
  38.             // 尝试用 cas 获得, 这里体现了非公平性: 不去检查 AQS 队列
  39.             if (compareAndSetState(0, acquires)) {
  40.                 setExclusiveOwnerThread(current);
  41.                 return true;
  42.             }
  43.         }
  44.         // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
  45.         else if (current == getExclusiveOwnerThread()) {
  46.             // state++
  47.             int nextc = c + acquires;
  48.             if (nextc < 0) // overflow
  49.                 throw new Error("Maximum lock count exceeded");
  50.             setState(nextc);
  51.             return true;
  52.         }
  53.         // 获取失败, 回到调用处
  54.         return false;
  55.     }
  57.     // ㈣ AQS 继承过来的方法, 方便阅读, 放在此处
  58.     private Node addWaiter(Node mode) {
  59.         // 将当前线程关联到一个 Node 对象上, 模式为独占模式
  60.         Node node = new Node(Thread.currentThread(), mode);
  61.         // 如果 tail 不为 null, cas 尝试将 Node 对象加入 AQS 队列尾部
  62.         Node pred = tail;
  63.         if (pred != null) {
  64.             node.prev = pred;
  65.             if (compareAndSetTail(pred, node)) {
  66.                 // 双向链表
  67.                 pred.next = node;
  68.                 return node;
  69.             }
  70.         }
  71.         // 尝试将 Node 加入 AQS, 进入 ㈥
  72.         enq(node);
  73.         return node;
  74.     }
  76.     // ㈥ AQS 继承过来的方法, 方便阅读, 放在此处
  77.     private Node enq(final Node node) {
  78.         for (;;) {
  79.             Node t = tail;
  80.             if (t == null) {
  81.                 // 还没有, 设置 head 为哨兵节点（不对应线程，状态为 0）
  82.                 if (compareAndSetHead(new Node())) {
  83.                     tail = head;
  84.                 }
  85.             } else {
  86.                 // cas 尝试将 Node 对象加入 AQS 队列尾部
  87.                 node.prev = t;
  88.                 if (compareAndSetTail(t, node)) {
  89.                     t.next = node;
  90.                     return t;
  91.                 }
  92.             }
  93.         }
  94.     }
  96.     // ㈤ AQS 继承过来的方法, 方便阅读, 放在此处
  97.     final boolean acquireQueued(final Node node, int arg) {
  98.         boolean failed = true;
  99.         try {
  100.             boolean interrupted = false;
  101.             for (;;) {
  102.                 final Node p = node.predecessor();
  103.                 // 上一个节点是 head, 表示轮到自己（当前线程对应的 node）了, 尝试获取
  104.                 if (p == head && tryAcquire(arg)) {
  105.                     // 获取成功, 设置自己（当前线程对应的 node）为 head
  106.                     setHead(node);
  107.                     // 上一个节点 help GC
  108.                     p.next = null;
  109.                     failed = false;
  110.                     // 返回中断标记 false
  111.                     return interrupted;
  112.                 }
  113.                 if (
  114.                     // 判断是否应当 park, 进入 ㈦
  115.                     shouldParkAfterFailedAcquire(p, node) &&
  116.                     // park 等待, 此时 Node 的状态被置为 Node.SIGNAL ㈧
  117.                     parkAndCheckInterrupt()
  118.                 ) {
  119.                     interrupted = true;
  120.                 }
  121.             }
  122.         } finally {
  123.             if (failed)
  124.                 cancelAcquire(node);
  125.         }
  126.     }
  128.     // ㈦ AQS 继承过来的方法, 方便阅读, 放在此处
  129.     private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  130.         // 获取上一个节点的状态
  131.         int ws = pred.waitStatus;
  132.         if (ws == Node.SIGNAL) {
  133.             // 上一个节点都在阻塞, 那么自己也阻塞好了
  134.             return true;
  135.         }
  136.         // > 0 表示取消状态
  137.         if (ws > 0) {
  138.             // 上一个节点取消, 那么重构删除前面所有取消的节点, 返回到外层循环重试
  139.             do {
  140.                 node.prev = pred = pred.prev;
  141.             } while (pred.waitStatus > 0);
  142.             pred.next = node;
  143.         } else {
  144.             // 这次还没有阻塞
  145.             // 但下次如果重试不成功, 则需要阻塞，这时需要设置上一个节点状态为 Node.SIGNAL
  146.             compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
  147.         }
  148.         return false;
  149.     }
  151.     // ㈧ 阻塞当前线程
  152.     private final boolean parkAndCheckInterrupt() {
  153.         LockSupport.park(this);
  154.         return Thread.interrupted();
  155.     }
  156. }

2、 解锁源码

  1. // Sync 继承自 AQS
  2. static final class NonfairSync extends Sync {
  3.     // 解锁实现
  4.     public void unlock() {
  5.         sync.release(1);
  6.     }
  8.     // AQS 继承过来的方法, 方便阅读, 放在此处
  9.     public final boolean release(int arg) {
  10.         // 尝试释放锁, 进入 ㈠
  11.         if (tryRelease(arg)) {
  12.             // 队列头节点 unpark
  13.             Node h = head;
  14.             if (
  15.                 // 队列不为 null
  16.                 h != null &&
  17.                 // waitStatus == Node.SIGNAL 才需要 unpark
  18.                 h.waitStatus != 0
  19.             ) {
  20.                 // unpark AQS 中等待的线程, 进入 ㈡
  21.                 unparkSuccessor(h);
  22.             }
  23.             return true;
  24.         }
  25.         return false;
  26.     }
  28.     // ㈠ Sync 继承过来的方法, 方便阅读, 放在此处
  29.     protected final boolean tryRelease(int releases) {
  30.         // state--
  31.         int c = getState() - releases;
  32.         if (Thread.currentThread() != getExclusiveOwnerThread())
  33.             throw new IllegalMonitorStateException();
  34.         boolean free = false;
  35.         // 支持锁重入, 只有 state 减为 0, 才释放成功
  36.         if (c == 0) {
  37.             free = true;
  38.             setExclusiveOwnerThread(null);
  39.         }
  40.         setState(c);
  41.         return free;
  42.     }
  44.     // ㈡ AQS 继承过来的方法, 方便阅读, 放在此处
  45.     private void unparkSuccessor(Node node) {
  46.         // 如果状态为 Node.SIGNAL 尝试重置状态为 0
  47.         // 不成功也可以
  48.         int ws = node.waitStatus;
  49.         if (ws < 0) {
  50.             compareAndSetWaitStatus(node, ws, 0);
  51.         }
  52.         // 找到需要 unpark 的节点, 但本节点从 AQS 队列中脱离, 是由唤醒节点完成的
  53.         Node s = node.next;
  54.         // 不考虑已取消的节点, 从 AQS 队列从后至前找到队列最前面需要 unpark 的节点
  55.         if (s == null || s.waitStatus > 0) {
  56.             s = null;
  57.             for (Node t = tail; t != null && t != node; t = t.prev)
  58.                 if (t.waitStatus <= 0)
  59.                     s = t;
  60.         }
  61.         if (s != null)
  62.             LockSupport.unpark(s.thread);
  63.     }
  64. }

2、 可重入原理

  1. static final class NonfairSync extends Sync {
  2.     // ...
  4.     // Sync 继承过来的方法, 方便阅读, 放在此处
  5.     final boolean nonfairTryAcquire(int acquires) {
  6.         final Thread current = Thread.currentThread();
  7.         int c = getState();
  8.         if (c == 0) {
  9.             if (compareAndSetState(0, acquires)) {
  10.                 setExclusiveOwnerThread(current);
  11.                 return true;
  12.             }
  13.         }
  14.         // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
  15.         else if (current == getExclusiveOwnerThread()) {
  16.             // state++
  17.             int nextc = c + acquires;
  18.             if (nextc < 0) // overflow
  19.                 throw new Error("Maximum lock count exceeded");
  20.             setState(nextc);
  21.             return true;
  22.         }
  23.         return false;
  24.     }
  26.     // Sync 继承过来的方法, 方便阅读, 放在此处
  27.     protected final boolean tryRelease(int releases) {
  28.         // state--
  29.         int c = getState() - releases;
  30.         if (Thread.currentThread() != getExclusiveOwnerThread())
  31.             throw new IllegalMonitorStateException();
  32.         boolean free = false;
  33.         // 支持锁重入, 只有 state 减为 0, 才释放成功
  34.         if (c == 0) {
  35.             free = true;
  36.             setExclusiveOwnerThread(null);
  37.         }
  38.         setState(c);
  39.         return free;
  40.     }
  41. }

3、可打断原理

不可打断模式

在此模式下，即使它被打断，仍会驻留在 AQS 队列中，一直要等到获得锁后方能得知自己被打断了 

  1. // Sync 继承自 AQS
  2. static final class NonfairSync extends Sync {
  3.     // ...
  5.     private final boolean parkAndCheckInterrupt() {
  6.         // 如果打断标记已经是 true, 则 park 会失效
  7.         LockSupport.park(this);
  8.         // interrupted 会清除打断标记
  9.         return Thread.interrupted();
  10.     }
  12.     final boolean acquireQueued(final Node node, int arg) {
  13.         boolean failed = true;
  14.         try {
  15.             boolean interrupted = false;
  16.             for (;;) {
  17.                 final Node p = node.predecessor();
  18.                 if (p == head && tryAcquire(arg)) {
  19.                     setHead(node);
  20.                     p.next = null;
  21.                     failed = false;
  22.                     // 还是需要获得锁后, 才能返回打断状态
  23.                     return interrupted;
  24.                 }
  25.                 if (
  26.                     shouldParkAfterFailedAcquire(p, node) &&
  27.                     parkAndCheckInterrupt()
  28.                 ) {
  29.                     // 如果是因为 interrupt 被唤醒, 返回打断状态为 true
  30.                     interrupted = true;
  31.                 }
  32.             }
  33.         } finally {
  34.             if (failed)
  35.                 cancelAcquire(node);
  36.         }
  37.     }
  39.     public final void acquire(int arg) {
  40.         if (
  41.             !tryAcquire(arg) &&
  42.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
  43.         ) {
  44.             // 如果打断状态为 true
  45.             selfInterrupt();
  46.         }
  47.     }
  49.     static void selfInterrupt() {
  50.         // 重新产生一次中断
  51.         Thread.currentThread().interrupt();
  52.     }
  53. }

可打断模式

  1. static final class NonfairSync extends Sync {
  2.     public final void acquireInterruptibly(int arg) throws InterruptedException {
  3.         if (Thread.interrupted())
  4.             throw new InterruptedException();
  5.         // 如果没有获得到锁, 进入 ㈠
  6.         if (!tryAcquire(arg))
  7.             doAcquireInterruptibly(arg);
  8.     }
  10.     // ㈠ 可打断的获取锁流程
  11.     private void doAcquireInterruptibly(int arg) throws InterruptedException {
  12.         final Node node = addWaiter(Node.EXCLUSIVE);
  13.         boolean failed = true;
  14.         try {
  15.             for (;;) {
  16.                 final Node p = node.predecessor();
  17.                 if (p == head && tryAcquire(arg)) {
  18.                     setHead(node);
  19.                     p.next = null; // help GC
  20.                     failed = false;
  21.                     return;
  22.                 }
  23.                 if (shouldParkAfterFailedAcquire(p, node) &&
  24.                     parkAndCheckInterrupt()) {
  25.                     // 在 park 过程中如果被 interrupt 会进入此
  26.                     // 这时候抛出异常, 而不会再次进入 for (;;)
  27.                     throw new InterruptedException();
  28.                 }
  29.             }
  30.         } finally {
  31.             if (failed)
  32.                 cancelAcquire(node);
  33.         }
  34.     }
  35. }

4、 公平锁实现原理

  1. static final class FairSync extends Sync {
  2.     private static final long serialVersionUID = -3000897897090466540L;
  3.     final void lock() {
  4.         acquire(1);
  5.     }
  7.     // AQS 继承过来的方法, 方便阅读, 放在此处
  8.     public final void acquire(int arg) {
  9.         if (
  10.             !tryAcquire(arg) &&
  11.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
  12.         ) {
  13.             selfInterrupt();
  14.         }
  15.     }
  16.     // 与非公平锁主要区别在于 tryAcquire 方法的实现
  17.     protected final boolean tryAcquire(int acquires) {
  18.         final Thread current = Thread.currentThread();
  19.         int c = getState();
  20.         if (c == 0) {
  21.             // 先检查 AQS 队列中是否有前驱节点, 没有才去竞争
  22.             if (!hasQueuedPredecessors() &&
  23.                 compareAndSetState(0, acquires)) {
  24.                 setExclusiveOwnerThread(current);
  25.                 return true;
  26.             }
  27.         }
  28.         else if (current == getExclusiveOwnerThread()) {
  29.             int nextc = c + acquires;
  30.             if (nextc < 0)
  31.                 throw new Error("Maximum lock count exceeded");
  32.             setState(nextc);
  33.             return true;
  34.         }
  35.         return false;
  36.     }
  38.     // ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
  39.     public final boolean hasQueuedPredecessors() {
  40.         Node t = tail;
  41.         Node h = head;
  42.         Node s;
  43.         // h != t 时表示队列中有 Node
  44.         return h != t &&
  45.             (
  46.             // (s = h.next) == null 表示队列中还有没有老二
  47.             (s = h.next) == null ||
  48.             // 或者队列中老二线程不是此线程
  49.             s.thread != Thread.currentThread()
  50.         );
  51.     }
  52. }

5、 条件变量实现原理

每个条件变量其实就对应着一个等待队列，其实现类是 ConditionObject

await 流程

开始 Thread-0 持有锁，调用 await，进入 ConditionObject 的 addConditionWaiter 流程 创建新的 Node 状态为 -2（Node.CONDITION），关联 Thread-0，加入等待队列尾部
image.png
接下来进入 AQS 的 fullyRelease 流程，释放同步器上的锁
image.png
unpark AQS 队列中的下一个节点，竞争锁，假设没有其他竞争线程，那么 Thread-1 竞争成功
image.png
park 阻塞 Thread-0
image.png

signal 流程

假设 Thread-1 要来唤醒 Thread-0
image.png
进入 ConditionObject 的 doSignal 流程，取得等待队列中第一个 Node，即 Thread-0 所在 Node
image.png
执行 transferForSignal 流程，将该 Node 加入 AQS 队列尾部，将 Thread-0 的 waitStatus 改为 0，Thread-3 的 waitStatus 改为 -1
image.png
Thread-1 释放锁，进入 unlock 流程，略

源码

  1. public class ConditionObject implements Condition, java.io.Serializable {
  2.     private static final long serialVersionUID = 1173984872572414699L;
  4.     // 第一个等待节点
  5.     private transient Node firstWaiter;
  7.     // 最后一个等待节点
  8.     private transient Node lastWaiter;
  9.     public ConditionObject() { }
  10.     // ㈠ 添加一个 Node 至等待队列
  11.     private Node addConditionWaiter() {
  12.         Node t = lastWaiter;
  13.         // 所有已取消的 Node 从队列链表删除, 见 ㈡
  14.         if (t != null && t.waitStatus != Node.CONDITION) {
  15.             unlinkCancelledWaiters();
  16.             t = lastWaiter;
  17.         }
  18.         // 创建一个关联当前线程的新 Node, 添加至队列尾部
  19.         Node node = new Node(Thread.currentThread(), Node.CONDITION);
  20.         if (t == null)
  21.             firstWaiter = node;
  22.         else
  23.             t.nextWaiter = node;
  24.         lastWaiter = node;
  25.         return node;
  26.     }
  27.     // 唤醒 - 将没取消的第一个节点转移至 AQS 队列
  28.     private void doSignal(Node first) {
  29.         do {
  30.             // 已经是尾节点了
  31.             if ( (firstWaiter = first.nextWaiter) == null) {
  32.                 lastWaiter = null;
  33.             }
  34.             first.nextWaiter = null;
  35.         } while (
  36.             // 将等待队列中的 Node 转移至 AQS 队列, 不成功且还有节点则继续循环 ㈢
  37.             !transferForSignal(first) &&
  38.             // 队列还有节点
  39.             (first = firstWaiter) != null
  40.         );
  41.     }
  43.     // 外部类方法, 方便阅读, 放在此处
  44.     // ㈢ 如果节点状态是取消, 返回 false 表示转移失败, 否则转移成功
  45.     final boolean transferForSignal(Node node) {
  46.         // 如果状态已经不是 Node.CONDITION, 说明被取消了
  47.         if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
  48.             return false;
  49.         // 加入 AQS 队列尾部
  50.         Node p = enq(node);
  51.         int ws = p.waitStatus;
  52.         if (
  53.             // 上一个节点被取消
  54.             ws > 0 ||
  55.             // 上一个节点不能设置状态为 Node.SIGNAL
  56.             !compareAndSetWaitStatus(p, ws, Node.SIGNAL)
  57.         ) {
  58.             // unpark 取消阻塞, 让线程重新同步状态
  59.             LockSupport.unpark(node.thread);
  60.         }
  61.         return true;
  62.     }
  63.     // 全部唤醒 - 等待队列的所有节点转移至 AQS 队列
  64.     private void doSignalAll(Node first) {
  65.         lastWaiter = firstWaiter = null;
  66.         do {
  67.             Node next = first.nextWaiter;
  68.             first.nextWaiter = null;
  69.             transferForSignal(first);
  70.             first = next;
  71.         } while (first != null);
  72.     }
  74.     // ㈡
  75.     private void unlinkCancelledWaiters() {
  76.         // ...
  77.     }
  78.     // 唤醒 - 必须持有锁才能唤醒, 因此 doSignal 内无需考虑加锁
  79.     public final void signal() {
  80.         if (!isHeldExclusively())
  81.             throw new IllegalMonitorStateException();
  82.         Node first = firstWaiter;
  83.         if (first != null)
  84.             doSignal(first);
  85.     }
  86.     // 全部唤醒 - 必须持有锁才能唤醒, 因此 doSignalAll 内无需考虑加锁
  87.     public final void signalAll() {
  88.         if (!isHeldExclusively())
  89.             throw new IllegalMonitorStateException();
  90.         Node first = firstWaiter;
  91.         if (first != null)
  92.             doSignalAll(first);
  93.     }
  94.     // 不可打断等待 - 直到被唤醒
  95.     public final void awaitUninterruptibly() {
  96.         // 添加一个 Node 至等待队列, 见 ㈠
  97.         Node node = addConditionWaiter();
  98.         // 释放节点持有的锁, 见 ㈣
  99.         int savedState = fullyRelease(node);
  100.         boolean interrupted = false;
  101.         // 如果该节点还没有转移至 AQS 队列, 阻塞
  102.         while (!isOnSyncQueue(node)) {
  103.             // park 阻塞
  104.             LockSupport.park(this);
  105.             // 如果被打断, 仅设置打断状态
  106.             if (Thread.interrupted())
  107.                 interrupted = true;
  108.         }
  109.         // 唤醒后, 尝试竞争锁, 如果失败进入 AQS 队列
  110.         if (acquireQueued(node, savedState) || interrupted)
  111.             selfInterrupt();
  112.     }
  114.     // 外部类方法, 方便阅读, 放在此处
  115.     // ㈣ 因为某线程可能重入，需要将 state 全部释放
  116.     final int fullyRelease(Node node) {
  117.         boolean failed = true;
  118.         try {
  119.             int savedState = getState();
  120.             if (release(savedState)) {
  121.                 failed = false;
  122.                 return savedState;
  123.             } else {
  124.                 throw new IllegalMonitorStateException();
  125.             }
  126.         } finally {
  127.             if (failed)
  128.                 node.waitStatus = Node.CANCELLED;
  129.         }
  130.     }
  131.     // 打断模式 - 在退出等待时重新设置打断状态
  132.     private static final int REINTERRUPT = 1;
  133.     // 打断模式 - 在退出等待时抛出异常
  134.     private static final int THROW_IE = -1;
  135.     // 判断打断模式
  136.     private int checkInterruptWhileWaiting(Node node) {
  137.         return Thread.interrupted() ?
  138.             (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
  139.         0;
  140.     }
  141.     // ㈤ 应用打断模式
  142.     private void reportInterruptAfterWait(int interruptMode)
  143.         throws InterruptedException {
  144.         if (interruptMode == THROW_IE)
  145.             throw new InterruptedException();
  146.         else if (interruptMode == REINTERRUPT)
  147.             selfInterrupt();
  148.     }
  149.     // 等待 - 直到被唤醒或打断
  150.     public final void await() throws InterruptedException {
  151.         if (Thread.interrupted()) {
  152.             throw new InterruptedException();
  153.         }
  154.         // 添加一个 Node 至等待队列, 见 ㈠
  155.         Node node = addConditionWaiter();
  156.         // 释放节点持有的锁
  157.         int savedState = fullyRelease(node);
  158.         int interruptMode = 0;
  159.         // 如果该节点还没有转移至 AQS 队列, 阻塞
  160.         while (!isOnSyncQueue(node)) {
  161.             // park 阻塞
  162.             LockSupport.park(this);
  163.             // 如果被打断, 退出等待队列
  164.             if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
  165.                 break;
  166.         }
  167.         // 退出等待队列后, 还需要获得 AQS 队列的锁
  168.         if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
  169.             interruptMode = REINTERRUPT;
  170.         // 所有已取消的 Node 从队列链表删除, 见 ㈡
  171.         if (node.nextWaiter != null)
  172.             unlinkCancelledWaiters();
  173.         // 应用打断模式, 见 ㈤
  174.         if (interruptMode != 0)
  175.             reportInterruptAfterWait(interruptMode);
  176.     }
  177.     // 等待 - 直到被唤醒或打断或超时
  178.     public final long awaitNanos(long nanosTimeout) throws InterruptedException {
  179.         if (Thread.interrupted()) {
  180.             throw new InterruptedException();
  181.         }
  182.         // 添加一个 Node 至等待队列, 见 ㈠
  183.         Node node = addConditionWaiter();
  184.         // 释放节点持有的锁
  185.         int savedState = fullyRelease(node);
  186.         // 获得最后期限
  187.         final long deadline = System.nanoTime() + nanosTimeout;
  188.         int interruptMode = 0;
  189.         // 如果该节点还没有转移至 AQS 队列, 阻塞
  190.         while (!isOnSyncQueue(node)) {
  191.             // 已超时, 退出等待队列
  192.             if (nanosTimeout <= 0L) {
  193.                 transferAfterCancelledWait(node);
  194.                 break;
  195.             }
  196.             // park 阻塞一定时间, spinForTimeoutThreshold 为 1000 ns
  197.             if (nanosTimeout >= spinForTimeoutThreshold)
  198.                 LockSupport.parkNanos(this, nanosTimeout);
  199.             // 如果被打断, 退出等待队列
  200.             if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
  201.                 break;
  202.             nanosTimeout = deadline - System.nanoTime();
  203.         }
  204.         // 退出等待队列后, 还需要获得 AQS 队列的锁
  205.         if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
  206.             interruptMode = REINTERRUPT;
  207.         // 所有已取消的 Node 从队列链表删除, 见 ㈡
  208.         if (node.nextWaiter != null)
  209.             unlinkCancelledWaiters();
  210.         // 应用打断模式, 见 ㈤
  211.         if (interruptMode != 0)
  212.             reportInterruptAfterWait(interruptMode);
  213.         return deadline - System.nanoTime();
  214.     }
  215.     // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
  216.     public final boolean awaitUntil(Date deadline) throws InterruptedException {
  217.         // ...
  218.     }
  219.     // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
  220.     public final boolean await(long time, TimeUnit unit) throws InterruptedException {
  221.         // ...
  222.     }
  223.     // 工具方法 省略 ...
  224. }