Java多线程与并发编程(6)_基于AQS的ReentrantLock 原理

梦里梦外; 2023-02-19 14:25 13阅读 0赞

# 基于AQS的ReentrantLock 原理 #

### 文章目录 ###

*  基于AQS的ReentrantLock 原理
 *   *  ReentrantLock与synchronized的区别
     *  非公平锁实现原理
     *   *  加锁解锁流程
     *  可重入锁实现源码注释
     *  可打断锁实现源码注释
     *   *  不可打断模式
         *  可打断模式
     *  公平锁实现源码注释
     *  条件变量实现原理
     *   *  await 流程
         *  signal 流程
         *  源码

## ReentrantLock与synchronized的区别 ##

两者的不同点：

*  ReentrantLock 是 API 级别的，synchronized 是 JVM 级别的
 *  ReentrantLock 显示的获得、释放锁，synchronized 隐式获得释放锁
 *  ReentrantLock 可响应中断、可轮回，synchronized 是不可以响应中断的
 *  ReentrantLock 通过 Condition（等待队列） 可以绑定多个条件-
 *  synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁。
 *  ReentrantLock 支持读写锁机制

> ## 非公平锁实现原理 ##

> ### 加锁解锁流程 ###
> 
> 先从构造器开始看，**默认为非公平锁实现**
> 
>  *  公平锁：线程抢锁先去阻塞队列排队
>  *  非公平锁：先看锁是否被占用，不占用直接上锁
> 
>     public ReentrantLock() {
>          
>             sync = new NonfairSync();
>         }
> 
> `NonfairSync` 继承自 AQS（同步器），它长这个样子
> 
> ![format_png][]
> 
> > 在本文第一段引用的文章末尾，我介绍了AQS的阻塞队列相关，里面对这把同步器里的几个元素作了解释，各位可自行查看
> 
> **在有一个线程持有这把锁时，它长这个样子**：
> 
> ![format_png 1][]
> 
> **第一个竞争出现时**：
> 
>     public void lock() {
>          
>             sync.lock();
>         }
>     **************************************************************************
>             final void lock() {
>          
>        				 //首先用 cas 尝试（仅尝试一次）将 state 从 0 改为 1, 如果成功表示获得了独占锁
>       					//非公平的体现
>                 if (compareAndSetState(0, 1)) //0——>1
>                     setExclusiveOwnerThread(Thread.currentThread());
>                 else
>                     // 如果尝试失败，进入阻塞队列等待唤醒
>                     acquire(1);
>             }
>     **************************************************************************
>         // ㈠ AQS 继承过来的方法
>     
>         public final void acquire(int arg) {
>          
>             if (!tryAcquire(arg) &&
>                 // 当 tryAcquire 返回为 false 时, 先调用 addWaiter , 接着 acquireQueued 
>                 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
>               	//acquire失败 自我打断
>                 selfInterrupt();
>         }
>     **************************************************************************
> 
> ![format_png 2][]
> 
> **线程2执行了**：
> 
> 1.  CAS 尝试将 state 由 0 改为 1，结果失败
> 2.  进入 tryAcquire 逻辑，这时 state 已经是1，结果仍然失败
> 3.  接下来进入 addWaiter 逻辑，构造 Node 队列（Node是AQS提供的队列节点）
> 
>     //构造阻塞队列的Node对象  
>     private Node addWaiter(Node mode) {
>          
>     
>             // 将当前线程关联到一个 Node 对象上, 模式为独占模式
>             Node node = new Node(Thread.currentThread(), mode);
>             Node pred = tail; 
>             // 如果 tail 不为 null, cas 尝试将 Node 对象加入 AQS 队列尾部
>             if (pred != null) {
>          
>                 node.prev = pred; 
>                 //CAS设置自己为尾部
>                 if (compareAndSetTail(pred, node)) {
>             
>                     pred.next = node;
>                     return node;
>                 }
>             }
>             //如果线程无人占有
>             enq(node);
>             return node;
>         }
>     **************************************************************************
>     
>     
>         private Node enq(final Node node) {
>          
>            for (;;) {
>          
>            	 Node t = tail;
>              if (t == null) {
>          
>              //尝试做哨兵
>              if (compareAndSetHead(new Node())) {
>          
>             	 tail = head;
>              }
>              } else {
>          
>              // cas 尝试将 Node 对象加入 AQS 队列尾部
>              node.prev = t;
>              if (compareAndSetTail(t, node)) {
>          
>              t.next = node;
>              return t;
>            }} }}
> 
> 完成后，形成了这样一个数据结构
> 
> ![format_png 3][]
> 
>  *  图中黄色三角表示该 Node 的 waitStatus 状态，其中 0 为默认正常状态
>  *  Node 的创建是懒惰的
>  *  其中第一个 Node 称为 Dummy（哑元）或哨兵，用来占位，并不关联线程，主要作用是唤醒与之关联的线程
> 
> 当前线程进入 acquireQueued 逻辑
> 
>     final boolean acquireQueued(final Node node, int arg) {
>          
>             boolean failed = true;
>             try {
>          
>                 boolean interrupted = false;
>                 //死循环
>                 for (;;) {
>          
>                     //获得当前线程前驱节点：head
>                     final Node p = node.predecessor();
>                    // 上一个节点是 head（哨兵）, 表示轮到自己（当前线程对应的 node）了, 尝试获取
>                     if (p == head && tryAcquire(arg)) {
>          
>                         // 获取成功, 设置自己（当前线程对应的 node）为 head哨兵
>                         setHead(node);
>                         p.next = null; // help GC
>                         failed = false;
>                         return interrupted;
>                     }
>                     //锁被另一个线程占有，失败
>                     if (shouldParkAfterFailedAcquire(p, node) &&
>                         //park并检查是否被打断，是则设置打断标记， 此时 Node 的状态被置为 Node.SIGNAL
>                         parkAndCheckInterrupt())
>                         interrupted = true;
>                 }
>             } finally {
>          
>                 if (failed)
>                     //放弃申请锁
>                     cancelAcquire(node);
>             }
>         }
>     
>     
>     **************************************************************************
>      private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
>          
>      // 获取上一个节点的状态
>          int ws = pred.waitStatus;
>          if (ws == Node.SIGNAL) {
>          
>            // 上一个节点都在阻塞, 那么自己也阻塞好了
>            return true;
>          }
>          // > 0 表示取消状态
>          if (ws > 0) {
>          
>          // 上一个节点取消, 那么重构删除前面所有取消的节点, 返回到外层循环重试
>          do {
>          
>          	node.prev = pred = pred.prev;
>          } while (pred.waitStatus > 0);
>          		pred.next = node;
>          } else {
>          
>          // 这次还没有阻塞
>          // 但下次如果重试不成功, 则需要阻塞，这时需要设置上一个节点状态为 Node.SIGNAL
>        		  compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
>          }
>          return false;
>      }
>     
>     **************************************************************************
>      // 阻塞当前线程
>      private final boolean parkAndCheckInterrupt() {
>          
>          LockSupport.park(this);
>          return Thread.interrupted();
>      }
>     }
> 
> ![format_png 4][]
> 
> 1.  `acquireQueued` 会在一个死循环中不断尝试获得锁，失败后进入 park 阻塞
> 2.  如果自己是紧邻着 head（排第二位），那么再次 `tryAcquire` 尝试获取锁，当然这时 state 仍为 1，失败
> 3.  进入 `shouldParkAfterFailedAcquire` 逻辑，将前驱 node，即 head 的 waitStatus 改为 -1，这次返回 false
> 
> **当再次有多个线程经历上述过程竞争失败，变成这个样子**：
> 
> ![format_png 5][]
> 
> 线程1释放锁，进入 tryRelease 流程，如果成功
> 
>  *  设置 exclusiveOwnerThread 为 null
>  *  state = 0
> 
>     public final boolean release(int arg) {
>          
>             // 尝试释放锁
>             if (tryRelease(arg)) {
>          
>                 // 队列头节点 unpark
>                 Node h = head;
>                 if (h != null && h.waitStatus != 0)
>                     // unpark AQS 中等待的线程
>                     unparkSuccessor(h);
>                 return true;
>             }
>             return false;
>         }        
>     
>     **************************************************************************
>     protected final boolean tryRelease(int releases) {
>          
>                 // state--，重入的线程释放时的releases为重入的次数
>                 int c = getState() - releases; //1-1
>                 if (Thread.currentThread() != getExclusiveOwnerThread())
>                     throw new IllegalMonitorStateException();
>                 boolean free = false;
>                // 支持锁重入, 只有 state 减为 0, 才释放成功 
>                 if (c == 0) {
>          
>                     free = true;
>                     //设置 exclusiveOwnerThread 为 null
>                     setExclusiveOwnerThread(null);
>                 }
>                 //设置锁为正常状态0
>                 setState(c);
>                 return free;
>             }
> 
> 此时，阻塞队列不为 null，并且 head 的 waitStatus = -1，进入 unparkSuccessor 流程
> 
>  *  找到队列中离 head 最近的一个 Node（没取消的），unpark 恢复其运行，本例中即为线程2
> 
>     private void unparkSuccessor(Node node) {
>          
>             // 如果状态为 Node.SIGNAL 尝试重置状态为 0
>      		// 不成功也可以
>             int ws = node.waitStatus;
>             if (ws < 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);
>         }
> 
> **回到线程2 的 acquireQueued 流程（死循环睡眠）**：
> 
>     for (;;) {
>          
>                     //获取当前线程节点的前驱
>                     final Node p = node.predecessor();
>                     //如果正好排到自己且竞争锁成功
>                     if (p == head && tryAcquire(arg)) {
>          
>               		 setHead(node);
>     
>     **************************************************************************          
>          private void setHead(Node node) {
>          
>         	//head 指向刚刚线程2所在的 Node
>             head = node;
>         	//node作为哨兵	
>             node.thread = null;
>             node.prev = null;
>         }
>     
>     **************************************************************************      
>     
>                         //原本的head从链表断开，而可被垃圾回收
>                         p.next = null; // help GC
>                         failed = false;
>                         return interrupted;
>                     }
> 
> 如果加锁成功（没有竞争），会设置
> 
>  *  exclusiveOwnerThread 为线程2，state = 1
>  *  head 指向刚刚线程2所在的 Node
>  *  原本的 head 因为从链表断开，而可被垃圾回收
> 
> **此时，数据结构是这样的**：
> 
> ![format_png 6][]
> 
> > **注意：如果这时候有其它线程来竞争（非公平的体现），在Sync状态设置为0时，其他线程是可以绕过阻塞队列直接占有这把锁的**
> > 
> > 如果被别的线程“钻了空子”，则
> > 
> > Thread-4 被设置为 exclusiveOwnerThread，state = 1
> > 
> > Thread-1 再次进入 acquireQueued 流程，获取锁失败，重新进入 park 阻塞
> 
> > ## 可重入锁实现源码注释 ##
> > 
> >     static final class NonfairSync extends Sync {
> >           
> >     // ...
> >     
> >     // Sync 继承过来的方法, 方便阅读, 放在此处
> >     final boolean nonfairTryAcquire(int acquires) {
> >           
> >     final Thread current = Thread.currentThread();
> >     int c = getState();
> >     if (c == 0) {
> >           
> >     if (compareAndSetState(0, acquires)) {
> >           
> >     setExclusiveOwnerThread(current);
> >     return true;
> >     }
> >     }
> >     // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
> >     else if (current == getExclusiveOwnerThread()) {
> >           
> >     // state++
> >     int nextc = c + acquires;
> >     if (nextc < 0) // overflow
> >     throw new Error("Maximum lock count exceeded");
> >     setState(nextc);
> >     return true;
> >     }
> >     return false;
> >     }
> >     
> >     // Sync 继承过来的方法, 方便阅读, 放在此处
> >     protected final boolean tryRelease(int releases) {
> >           
> >     // state-- 
> >     int c = getState() - releases;
> >     if (Thread.currentThread() != getExclusiveOwnerThread())
> >     throw new IllegalMonitorStateException();
> >     boolean free = false;
> >     // 支持锁重入, 只有 state 减为 0, 才释放成功
> >     if (c == 0) {
> >           
> >     free = true;
> >     setExclusiveOwnerThread(null);
> >     }
> >     setState(c);
> >     return free;
> >     }
> >     }
> 
> > ## 可打断锁实现源码注释 ##
> > 
> > ### 不可打断模式 ###
> > 
> > 在此模式下，即使它被打断，仍会驻留在 AQS 队列中，一直要等到获得锁后方能得知自己被打断了
> > 
> >     // Sync 继承自 AQS
> >     static final class NonfairSync extends Sync {
> >           
> >     // ...
> >     
> >     private final boolean parkAndCheckInterrupt() {
> >           
> >     // 如果打断标记已经是 true, 则 park 会失效
> >     LockSupport.park(this);
> >     // interrupted 会清除打断标记
> >     return Thread.interrupted();
> >     }
> >     
> >     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);
> >     p.next = null;
> >     failed = false;
> >     // 还是需要获得锁后, 才能返回打断状态
> >     return interrupted;
> >     }
> >     if (
> >     shouldParkAfterFailedAcquire(p, node) &&
> >     parkAndCheckInterrupt()
> >     ) {
> >           
> >     // 如果是因为 interrupt 被唤醒, 返回打断状态为 true
> >     interrupted = true;
> >     }
> >     }
> >     } finally {
> >           
> >     if (failed)
> >     cancelAcquire(node);
> >     }
> >     }
> >     
> >     public final void acquire(int arg) {
> >           
> >     if (
> >     !tryAcquire(arg) &&
> >     acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
> >     ) {
> >           
> >     // 如果打断状态为 true
> >     selfInterrupt();
> >     }
> >     }
> >     
> >     static void selfInterrupt() {
> >           
> >     // 重新产生一次中断
> >     Thread.currentThread().interrupt();
> >     }
> >     }
> > 
> > ### 可打断模式 ###
> > 
> >     static final class NonfairSync extends Sync {
> >           
> >     public final void acquireInterruptibly(int arg) throws InterruptedException {
> >           
> >     if (Thread.interrupted())
> >     throw new InterruptedException();
> >     // 如果没有获得到锁, 进入 ㈠
> >     if (!tryAcquire(arg))
> >     doAcquireInterruptibly(arg);
> >     }
> >     
> >     // ㈠ 可打断的获取锁流程
> >     private void doAcquireInterruptibly(int arg) throws InterruptedException {
> >           
> >     final Node node = addWaiter(Node.EXCLUSIVE);
> >     boolean failed = true;
> >     try {
> >           
> >     for (;;) {
> >           
> >     final Node p = node.predecessor();
> >     if (p == head && tryAcquire(arg)) {
> >           
> >     setHead(node);
> >     p.next = null; // help GC
> >     failed = false;
> >     return;
> >     }
> >     if (shouldParkAfterFailedAcquire(p, node) &&
> >     parkAndCheckInterrupt()) {
> >           
> >     // 在 park 过程中如果被 interrupt 会进入此
> >     // 这时候抛出异常, 而不会再次进入 for (;;)
> >     throw new InterruptedException();
> >     }
> >     }
> >     } finally {
> >           
> >     if (failed)
> >     cancelAcquire(node);
> >     }
> >     }
> >     }
> 
> > ## 公平锁实现源码注释 ##
> > 
> >     static final class FairSync extends Sync {
> >           
> >     private static final long serialVersionUID = -3000897897090466540L;
> >     final void lock() {
> >           
> >     acquire(1);
> >     }
> >     
> >     // AQS 继承过来的方法, 方便阅读, 放在此处
> >     public final void acquire(int arg) {
> >           
> >     if (
> >     !tryAcquire(arg) &&
> >     acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
> >     ) {
> >           
> >     selfInterrupt();
> >     }
> >     }
> >     // 与非公平锁主要区别在于 tryAcquire 方法的实现
> >     protected final boolean tryAcquire(int acquires) {
> >           
> >     final Thread current = Thread.currentThread();
> >     int c = getState();
> >     if (c == 0) {
> >           
> >     // 先检查 AQS 队列中是否有前驱节点, 没有才去竞争
> >     if (!hasQueuedPredecessors() &&
> >     compareAndSetState(0, acquires)) {
> >           
> >     setExclusiveOwnerThread(current);
> >     return true;
> >     }
> >     }
> >     else if (current == getExclusiveOwnerThread()) {
> >           
> >     int nextc = c + acquires;
> >     if (nextc < 0)
> >     throw new Error("Maximum lock count exceeded");
> >     setState(nextc);
> >     return true;
> >     }
> >     return false;
> >     }
> >     
> >     // ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
> >     public final boolean hasQueuedPredecessors() {
> >           
> >     Node t = tail;
> >     Node h = head;
> >     Node s;
> >     // h != t 时表示队列中有 Node
> >     return h != t &&
> >     (
> >     // (s = h.next) == null 表示队列中还有没有老二
> >     (s = h.next) == null ||
> >     // 或者队列中老二线程不是此线程
> >     s.thread != Thread.currentThread()
> >     );
> >     }
> >     }
> 
> ## 条件变量实现原理 ##
> 
> 每个条件变量其实就对应着一个等待队列，其实现类是 ConditionObject
> 
> ### await 流程 ###
> 
> 开始 Thread-0 持有锁，调用 await，进入 ConditionObject 的 addConditionWaiter 流程
> 
> 创建新的 Node 状态为 -2（Node.CONDITION），关联 Thread-0，加入等待队列尾部
> 
> ![format_png 7][]
> 
> 接下来进入 AQS 的 fullyRelease 流程，释放同步器上的锁
> 
> ![format_png 8][]
> 
> unpark AQS 队列中的下一个节点，竞争锁，假设没有其他竞争线程，那么 Thread-1 竞争成功
> 
> ![format_png 9][]
> 
> park 阻塞 Thread-0
> 
> ![format_png 10][]
> 
> ### signal 流程 ###
> 
> 假设 Thread-1 要来唤醒 Thread-0
> 
> ![format_png 11][]
> 
> 进入 ConditionObject 的 doSignal 流程，取得等待队列中第一个 Node，即 Thread-0 所在 Node
> 
> ![format_png 12][]
> 
> 执行 transferForSignal 流程，将该 Node 加入 AQS 队列尾部，将 Thread-0 的 waitStatus 改为 0，Thread-3 的waitStatus 改为 -1
> 
> ![format_png 13][]
> 
> Thread-1 释放锁，进入 unlock 流程，略
> 
> ### 源码 ###
> 
>     public class ConditionObject implements Condition, java.io.Serializable {
>          
>      private static final long serialVersionUID = 1173984872572414699L;
>     
>      // 第一个等待节点
>      private transient Node firstWaiter;
>     
>      // 最后一个等待节点
>      private transient Node lastWaiter;
>      public ConditionObject() {
>           }
>      // ㈠ 添加一个 Node 至等待队列
>      private Node addConditionWaiter() {
>          
>      Node t = lastWaiter;
>      // 所有已取消的 Node 从队列链表删除, 见 ㈡
>       if (t != null && t.waitStatus != Node.CONDITION) {
>          
>      unlinkCancelledWaiters();
>      t = lastWaiter;
>      }
>      // 创建一个关联当前线程的新 Node, 添加至队列尾部
>      Node node = new Node(Thread.currentThread(), Node.CONDITION);
>      if (t == null)
>      firstWaiter = node;
>      else
>      t.nextWaiter = node;
>      lastWaiter = node;
>      return node;
>      }
>      // 唤醒 - 将没取消的第一个节点转移至 AQS 队列
>      private void doSignal(Node first) {
>          
>      do {
>          
>      // 已经是尾节点了
>      if ( (firstWaiter = first.nextWaiter) == null) {
>          
>      lastWaiter = null;
>      }
>      first.nextWaiter = null;
>      } while (
>      // 将等待队列中的 Node 转移至 AQS 队列, 不成功且还有节点则继续循环 ㈢
>      !transferForSignal(first) &&
>      // 队列还有节点
>      (first = firstWaiter) != null
>      );
>      }
>     
>      // 外部类方法, 方便阅读, 放在此处
>      // ㈢ 如果节点状态是取消, 返回 false 表示转移失败, 否则转移成功
>      final boolean transferForSignal(Node node) {
>          
>      // 如果状态已经不是 Node.CONDITION, 说明被取消了
>      if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
>      return false;
>      // 加入 AQS 队列尾部
>      Node p = enq(node);
>      int ws = p.waitStatus;
>      if (
>      // 上一个节点被取消
>      ws > 0 ||
>      // 上一个节点不能设置状态为 Node.SIGNAL
>      !compareAndSetWaitStatus(p, ws, Node.SIGNAL) 
>      ) {
>          
>      // unpark 取消阻塞, 让线程重新同步状态
>      LockSupport.unpark(node.thread);
>      }
>      return true;
>      }
>      // 全部唤醒 - 等待队列的所有节点转移至 AQS 队列
>       private void doSignalAll(Node first) {
>          
>      lastWaiter = firstWaiter = null;
>      do {
>          
>      Node next = first.nextWaiter;
>      first.nextWaiter = null;
>      transferForSignal(first);
>      first = next;
>      } while (first != null);
>      }
>     
>      // ㈡
>      private void unlinkCancelledWaiters() {
>          
>      // ...
>      }
>      // 唤醒 - 必须持有锁才能唤醒, 因此 doSignal 内无需考虑加锁
>      public final void signal() {
>          
>      if (!isHeldExclusively())
>      throw new IllegalMonitorStateException();
>      Node first = firstWaiter;
>      if (first != null)
>      doSignal(first);
>      }
>      // 全部唤醒 - 必须持有锁才能唤醒, 因此 doSignalAll 内无需考虑加锁
>      public final void signalAll() {
>          
>      if (!isHeldExclusively())
>      throw new IllegalMonitorStateException();
>      Node first = firstWaiter;
>      if (first != null)
>      doSignalAll(first);
>      }
>      // 不可打断等待 - 直到被唤醒
>      public final void awaitUninterruptibly() {
>          
>      // 添加一个 Node 至等待队列, 见 ㈠
>      Node node = addConditionWaiter();
>      // 释放节点持有的锁, 见 ㈣
>      int savedState = fullyRelease(node);
>      boolean interrupted = false;
>      // 如果该节点还没有转移至 AQS 队列, 阻塞
>      while (!isOnSyncQueue(node)) {
>          
>      // park 阻塞
>      LockSupport.park(this);
>      // 如果被打断, 仅设置打断状态
>      if (Thread.interrupted())
>      interrupted = true;
>      }
>      // 唤醒后, 尝试竞争锁, 如果失败进入 AQS 队列
>      if (acquireQueued(node, savedState) || interrupted)
>      selfInterrupt();
>      }
>       // 外部类方法, 方便阅读, 放在此处
>      // ㈣ 因为某线程可能重入，需要将 state 全部释放
>      final int fullyRelease(Node node) {
>          
>      boolean failed = true;
>      try {
>          
>      int savedState = getState();
>      if (release(savedState)) {
>          
>      failed = false;
>      return savedState;
>      } else {
>          
>      throw new IllegalMonitorStateException();
>      }
>      } finally {
>          
>      if (failed)
>      node.waitStatus = Node.CANCELLED;
>      }
>      }
>      // 打断模式 - 在退出等待时重新设置打断状态
>      private static final int REINTERRUPT = 1;
>      // 打断模式 - 在退出等待时抛出异常
>      private static final int THROW_IE = -1;
>      // 判断打断模式
>      private int checkInterruptWhileWaiting(Node node) {
>          
>      return Thread.interrupted() ?
>      (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
>      0;
>      }
>      // ㈤ 应用打断模式
>      private void reportInterruptAfterWait(int interruptMode)
>      throws InterruptedException {
>          
>      if (interruptMode == THROW_IE)
>      throw new InterruptedException();
>      else if (interruptMode == REINTERRUPT)
>      selfInterrupt();
>      }
>      // 等待 - 直到被唤醒或打断
>      public final void await() throws InterruptedException {
>          
>      if (Thread.interrupted()) {
>          
>      throw new InterruptedException();
>      }
>      // 添加一个 Node 至等待队列, 见 ㈠
>      Node node = addConditionWaiter();
>      // 释放节点持有的锁
>      int savedState = fullyRelease(node);
>      int interruptMode = 0;
>      // 如果该节点还没有转移至 AQS 队列, 阻塞
>      while (!isOnSyncQueue(node)) {
>          
>      // park 阻塞
>      LockSupport.park(this);
>       // 如果被打断, 退出等待队列
>      if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
>      break;
>      }
>      // 退出等待队列后, 还需要获得 AQS 队列的锁
>      if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
>      interruptMode = REINTERRUPT;
>      // 所有已取消的 Node 从队列链表删除, 见 ㈡
>      if (node.nextWaiter != null) 
>      unlinkCancelledWaiters();
>      // 应用打断模式, 见 ㈤
>      if (interruptMode != 0)
>      reportInterruptAfterWait(interruptMode);
>      }
>      // 等待 - 直到被唤醒或打断或超时
>      public final long awaitNanos(long nanosTimeout) throws InterruptedException {
>          
>      if (Thread.interrupted()) {
>          
>      throw new InterruptedException();
>      }
>      // 添加一个 Node 至等待队列, 见 ㈠
>      Node node = addConditionWaiter();
>      // 释放节点持有的锁
>      int savedState = fullyRelease(node);
>      // 获得最后期限
>      final long deadline = System.nanoTime() + nanosTimeout;
>      int interruptMode = 0;
>      // 如果该节点还没有转移至 AQS 队列, 阻塞
>      while (!isOnSyncQueue(node)) {
>          
>      // 已超时, 退出等待队列
>      if (nanosTimeout <= 0L) {
>          
>      transferAfterCancelledWait(node);
>      break;
>      }
>      // park 阻塞一定时间, spinForTimeoutThreshold 为 1000 ns
>      if (nanosTimeout >= spinForTimeoutThreshold)
>      LockSupport.parkNanos(this, nanosTimeout);
>      // 如果被打断, 退出等待队列
>      if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
>      break;
>      nanosTimeout = deadline - System.nanoTime();
>      }
>      // 退出等待队列后, 还需要获得 AQS 队列的锁
>      if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
>      interruptMode = REINTERRUPT;
>      // 所有已取消的 Node 从队列链表删除, 见 ㈡
>      if (node.nextWaiter != null)
>      unlinkCancelledWaiters();
>      // 应用打断模式, 见 ㈤
>      if (interruptMode != 0)
>      reportInterruptAfterWait(interruptMode);
>      return deadline - System.nanoTime();
>      }
>       // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
>      public final boolean awaitUntil(Date deadline) throws InterruptedException {
>          
>      // ...
>      }
>      // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
>      public final boolean await(long time, TimeUnit unit) throws InterruptedException {
>          
>      // ...
>      }
>      // 工具方法 省略 ...
>     }

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMjA2MTYucG5n?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMjEwMTgucG5n?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMjEzNDIucG5n?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMjQ3NTEucG5n?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMjU2NTMucG5n?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMzI0NDMucG5n?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwMzI3MzAucG5n?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA4MzAucG5n?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA4MTYucG5n?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA3NTAucG5n?x-oss-process=image/format,png
[format_png 10]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA3MjkucG5n?x-oss-process=image/format,png
[format_png 11]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA2NTcucG5n?x-oss-process=image/format,png
[format_png 12]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA2MzUucG5n?x-oss-process=image/format,png
[format_png 13]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjEwNDA2MTIucG5n?x-oss-process=image/format,png