JDK17 AbstractQueuedSynchronizer 二条件队列

2301_79308687

已于 2024-12-01 08:45:54 修改

阅读量631

点赞数 10

分类专栏： java 文章标签： jdk17 AQS 条件队列

于 2024-11-29 16:58:00 首次发布

本文链接：https://blog.csdn.net/2301_79308687/article/details/144101309

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

条件队列

同步队列中的线程是为了争抢锁，而条件队列中的线程是主动释放锁，挂起自己，等条件满足时被别的线程唤醒，继续工作。
在这里插入图片描述
AQS里只有1个同步队列，但可以有多个等待队列，每个等待队列对应一个ConditionObject对象。

public static void main(String[] args) {
	ReentrantLock lock = new ReentrantLock();
    Condition con1 = lock.newCondition();
    Condition con2 = lock.newCondition();
}
// ReentrantLock.java
final ConditionObject newCondition() {
  return new ConditionObject();
}

同步队列的头尾节点是head和tail，等待队列的头尾节点是firstWaiter和lastWaiter。
同步队列的头结点是哑节点，等待队列没有哑结点。
线程想进入同步队列是没有条件的，线程想进入等待队列得先获取锁，而且还得是独占锁。
同步队列的节点和等待队列的节点都是Node对象，线程离开等待队列后会进入同步队列，继续获取锁。

等待释放锁 await()

public final void await() throws InterruptedException {
     if (Thread.interrupted()) // 如果当前线程被设置了中断位，则1. 清除中断位，2. 抛出异常交给用户处理
         throw new InterruptedException();
     ConditionNode node = new ConditionNode(); // ConditionNode继承自Node类
     int savedState = enableWait(node); // 当前线程释放锁，并且组装node对象
     LockSupport.setCurrentBlocker(this); // for back-compatibility  向后兼容 与LockSupport.park()组合使用，让当前线程抛弃锁
     boolean interrupted = false, cancelled = false, rejected = false;
     while (!canReacquire(node)) { //  canReacquire表示当前节点是否离开等待对了，到了同步队列。如果是，则跳出循环
         if (interrupted |= Thread.interrupted()) { // 响应中断
             if (cancelled = (node.getAndUnsetStatus(COND) & COND) != 0) // 详见下文单独介绍这个语句，含义是如果被设置中断，并且当前节点仍然在等待队列，那么离开等待队列响应中断
                 break;              // else interrupted after signal
         } else if ((node.status & COND) != 0) { // 当前节点的status仍包含`COND`，即仍处于等待
             // 这个方法体目的是阻塞当前线程，如果能交给线程池提高并发更好，如果不能交给线程池则自己执行`LockSupport.park()`，自己挂起
             try {
                 if (rejected)
                     node.block();
                 else
                     ForkJoinPool.managedBlock(node);
             } catch (RejectedExecutionException ex) {
                 rejected = true;
             } catch (InterruptedException ie) {
                 interrupted = true;
             }
         } else // 代表上一个条件为false，即当前节点的status不包含`COND`，即已经离开等待队列。但是`canReacquire(node)=false`表示当前节点还未进入同步队列。因此放弃时间片等别的线程先执行。
             Thread.onSpinWait();    // awoke while enqueuing
     }
     // 运行到此，当前线程被唤醒，并且在同步队列里
     LockSupport.setCurrentBlocker(null);
     node.clearStatus(); // 原子性 node.status = 0
     acquire(node, savedState, false, false, false, 0L); // 尝试获取锁
      // 运行到此，当前线程已经重新获取资源
     if (interrupted) { // 响应中断
         if (cancelled) { // 当前节点从等待队列被取消，没有进入同步队列
             unlinkCancelledWaiters(node); // 清理当前节点和被设置为`CANCALLED`的节点
             throw new InterruptedException();
         }
         Thread.currentThread().interrupt();
     }
 }

private int enableWait(ConditionNode node) {
    if (isHeldExclusively()) { // 判断当前线程是否是持锁线程
        node.waiter = Thread.currentThread();
        node.setStatusRelaxed(COND | WAITING); // COND = 2,WAITING = 1, 因此node的status=3
        ConditionNode last = lastWaiter; // 开始将当前node对象放入条件队列
        if (last == null)
            firstWaiter = node;
        else
            last.nextWaiter = node;
        lastWaiter = node; // 结束将当前node对象放入条件队列
        int savedState = getState(); // 获取当前线程的state
        if (release(savedState)) // 释放锁，并且唤醒同步队列的下一个节点
            return savedState;
    }
    // 如果运行到此，说明1. 锁空闲，无持锁线程 或者2. 当前线程不是持锁线程，因此取消当前节点并且抛出异常
    node.status = CANCELLED; // lock not held or inconsistent
    throw new IllegalMonitorStateException();
}

（node.getAndUnsetStatus(COND) & COND) != 0

这个语句的目的是线程安全地将等待节点移出等待队列，即避免多个线程重复将同一个节点移出等待队列。线程如何知道节点在不在等待队列？通过status。如果status包含COND，表示还在等待队列，否则不在。

node.getAndUnsetstatus(COND)是node.status = node.status & ~COND，含义是解除COND位。原理是COND=2,用二进制表示是0010(从右往左第二位是1)，与非运算之后去掉status第二位的1。
在这里插入图片描述
(node.getAndUnsetStatus(COND) & COND) != 0=true表示当前节点仍然在等待队列。node.getAndUnsetstatus(COND)解除COND位之后返回的是初始status。node.getAndUnsetStatus(COND) & COND是初始状态与COND进行与运算，如果初始状态含COND，那么结果不等于0，含义是当前线程运行时当前节点仍然在等待队列。否则当前节点不在等待队列。
为什么不直接判断COND位，而是原子性操作呢？是为了线程安全。对于某个等待节点，多线程环境下只有第一个线程运行(node.getAndUnsetStatus(COND) & COND) != 0为true，只有它的getAndUnsetStatus(COND) 返回值包含COND位。之后的线程的getAndUnsetStatus(COND) 返回值都不包含COND位，(node.getAndUnsetStatus(COND) & COND) != 0结果永远是false，代表当前节点已经不在等待队列。

唤醒 signal与signalAl

public final void signal() {
   ConditionNode first = firstWaiter;
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    if (first != null)
        doSignal(first, false);
}

public final void signalAll() {
   ConditionNode first = firstWaiter;
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    if (first != null)
        doSignal(first, true);
}

private void doSignal(ConditionNode first, boolean all) {
   while (first != null) {
        ConditionNode next = first.nextWaiter;
        if ((firstWaiter = next) == null)
            lastWaiter = null;
        if ((first.getAndUnsetStatus(COND) & COND) != 0) {
            enqueue(first);
            if (!all)
                break;
        }
        first = next;
    }
}

signal()方法和signalAll()方法类似，都执行参数校验，并且交给doSignal()方法执行。
doSignal()方法将节点从等待队列移除，放入同步队列。并没有主动唤醒节点线程。
(first.getAndUnsetStatus(COND) & COND) != 0=true则当前线程是第一个去除first节点状态COND的线程。因此可以执行enqueue()方法将节点放入同步队列。
如果(first.getAndUnsetStatus(COND) & COND) != 0=false则代表当前线程从ConditionNode first = firstWaiter语句到本条语句期间，first节点的状态已经被别的线程更改了，跳过当前节点，尝试更改下一个节点。
signalAll()方法将all=true，代表所有等待节点都会被放入同步队列。