美文网首页
AbstractQueuedSynchronizer等待队列源码

AbstractQueuedSynchronizer等待队列源码

作者: sunpy | 来源:发表于2018-08-20 22:29 被阅读18次

内部实现类ConditionObject的继承与实现关系

//Condition接口的实现内部类  
public class ConditionObject implements Condition, java.io.Serializable

常用属性及构造器

/** 等待队列的头节点 */  
private transient Node firstWaiter;  
/** 等待队列的尾节点 */  
private transient Node lastWaiter;  
  
/** 
 * 无参构造器 
 */  
public ConditionObject() { }  

实现方法

await()方法:让当前线程处于等待状态。

await方法.png
      public final void await() throws InterruptedException {  
            // 如果当前线程中断,抛出中断异常  
            if (Thread.interrupted())  
                throw new InterruptedException();  
            // 将当前线程作为一个等待节点添加到等待队列,返回当前等待队列中的尾节点  
            // 此时该节点node的等待状态为Condition(在等待队列中)
            Node node = addConditionWaiter();  
            // 释放节点,就是将当前节点从同步队列中释放,返回保存的状态  
            int savedState = fullyRelease(node);  
            int interruptMode = 0;  
            // 循环判断的条件是node节点是否不在同步队列中  
            while (!isOnSyncQueue(node)) {  
                // 允许当前线程可用  
                LockSupport.park(this);  
                // 检查不处于等待状态时,是否中断,不为0,说明已经中断了,直接退出当前循环  
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)  
                    break;  
            }  
            // 如果节点node的前驱节点不为头节点,将阻塞node节点,一直等到其前驱节点为头节点为止
            // 并且中断模型对应的值不为中断状态  
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)  
                interruptMode = REINTERRUPT;  
            // 如果节点node的后继节点不为null  
            if (node.nextWaiter != null) // clean up if cancelled  
                // 释放等待队列中取消等待状态的节点
                unlinkCancelledWaiters();  
            // 如果当前中断模型值还是不为0,就是如果节点node还是处于中断情况  
            if (interruptMode != 0)  
                // 在等待状态之后,处理中断模型值  
                reportInterruptAfterWait(interruptMode);  
        }  

addConditionWaiter()方法:将当前线程作为一个等待节点添加到等待队列。

        private Node addConditionWaiter() {  
            // 获取等待队列的尾节点  
            Node t = lastWaiter;  
            // 如果尾节点不为null并且尾节点的等待状态不在等待队列中  
            if (t != null && t.waitStatus != Node.CONDITION) {  
                // 释放等待队列中取消等待状态的节点
                unlinkCancelledWaiters();  
                // 由于释放了等待队列中取消等待状态的节点,导致尾等待节点可能发生变化,需要重新赋值
                // 将t被赋值为等待队列的尾节点  
                t = lastWaiter;  
            }  
            // 将当前线程构造成一个处于等待队列中的节点  
            Node node = new Node(Thread.currentThread(), Node.CONDITION);  
            // 如果尾节点为空,说明等待队列中没有等待节点  
            if (t == null)  
                // 将当前线程构造的等待节点作为等待队列的头节点  
                firstWaiter = node;  
            else// 如果尾节点不为空,说明等待队列中存在等待节点  
                // 将当前线程构造的等待节点作为尾节点的后继节点  
                t.nextWaiter = node;  
            // 更新尾节点,将当前线程构造的节点作为尾节点  
            lastWaiter = node;  
            // 返回更新后尾节点  
            return node;  
        }  

unlinkCancelledWaiters()方法:释放等待队列中取消等待状态的节点。

      private void unlinkCancelledWaiters() {  
            // 获取等待队列的头节点  
            Node t = firstWaiter;  
            // 创建临时节点  
            Node trail = null;  
            // 从头节点开始遍历  
            while (t != null) {  
                // 获取当前遍历到的节点的后继节点  
                Node next = t.nextWaiter;  
                // 如果当前节点不在等待队列中  
                if (t.waitStatus != Node.CONDITION) {  
                    // 后继节点则设置为null  
                    t.nextWaiter = null;  
                    // 如果临时节点为空,那么当前节点设置为后继节点  
                    if (trail == null)  
                        firstWaiter = next;  
                    else// 如果临时节点不为空,那么临时节点的后继节点为当前节点的后继节点  
                        trail.nextWaiter = next;  
                    // 如果当前节点的后继节点为空,那么尾节点为临时节点  
                    if (next == null)
                        lastWaiter = trail;  
                }  
                else// 如果当前节点在等到队列中  
                    trail = t;// 将当前节点赋值给临时节点  
                t = next;// 后继节点作为当前遍历节点,向后遍历  
            }  
        }  

fullyRelease方法:将指定节点从同步队列中释放;如果释放失败,那么将指定节点的等待状态设置为不在等待队列中。

    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;
        }
    }

isOnSyncQueue方法:判断指定节点是否在同步队列中。

 final boolean isOnSyncQueue(Node node) {
        // 节点在等待队列中,肯定不在同步队列中
        // 节点不在等待队列中,而其前驱节点为空,说明已经不在同步队列中了
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        // 节点如果有后继节点,那么节点肯定在同步队列中
        if (node.next != null) // If has successor, it must be on queue
            return true;
       // 从同步队列的尾节点开始向前遍历查找指定节点
        return findNodeFromTail(node);
    }

    // 从同步队列的尾节点开始向前遍历查找,如果找到指定节点,那么返回true;如果未找到指定节点,那么返回false。
    private boolean findNodeFromTail(Node node) {
        Node t = tail;
        for (;;) {
            if (t == node)
                return true;
            if (t == null)
                return false;
            t = t.prev;
        }
    }

signal()方法:独占模式下,移出等待队列中等待时间最长的节点,将其移到同步队列。

signal方法.png
        public final void signal() {  
            // 如果当前线程不是以独占的方式运行的,那么就抛出异常  
            if (!isHeldExclusively())  
                throw new IllegalMonitorStateException();  
            // 获取等待队列的头节点  
            Node first = firstWaiter;  
            // 如果等待队列的头节点不为空  
            if (first != null)  
                // 将等待队列中的头节点从等待队列转移到同步队列  
                doSignal(first);  
        }  

doSignal(Node first)方法:将等待节点first从等待队列转移到同步队列。

        // 将等待节点first从等待队列转移到同步队列  
        private void doSignal(Node first) {  
            do {  
                // 如果输入节点的后继节点作为头节点,如果头节点为null  
                if ( (firstWaiter = first.nextWaiter) == null)  
                    // 尾节点设置为空  
                    lastWaiter = null;  
                // 输入节点的后继节点设置为null  
                first.nextWaiter = null;  
            } while (!transferForSignal(first) &&    // 将输入节点从等待队列转移到同步状态  
                    // 并且头节点不为空  
                     (first = firstWaiter) != null);  
        }  

transferForSignal方法:将等待节点从等待队列转移到同步队列

    final boolean transferForSignal(Node node) {
        // 原子的方式比较节点node如果在等待队列中,那么将node更新为在同步队列中
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        // 将节点插入到同步队列尾部
        Node p = enq(node);
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            // 将node节点对应线程可用
            LockSupport.unpark(node.thread);
        return true;
    }

doSignalAll(Node first)方法:将等待队列中的节点全部移出,然后转移到同步队列。

        // 将等待队列中的节点全部移出,然后转移到同步队列  
        private void doSignalAll(Node first) {  
            // 设置等待队列的头节点等于尾节点等于null(等待队列的置空操作)  
            lastWaiter = firstWaiter = null;  
            // 策略就是将等待队列中的节点遍历一遍,然后每个节点的后继关系解除,然后转移到同步队列中  
            do {  
                // 获取输入节点的后继节点  
                Node next = first.nextWaiter;  
                // 将后继节点设置为空  
                first.nextWaiter = null;  
                // 将等待队列中的节点转移到同步队列中  
                transferForSignal(first);  
                // 后继节点作为当前节点,依次向后遍历  
                first = next;  
            } while (first != null);// 直到遍历到尾节点  
        }  

说明:从头节点开始遍历等待队列中的节点,将每次遍历到的节点修改等待状态为在同步队列中,并将节点插入到同步队列的尾部。

总结

① 问题:节点什么时候从同步队列转移到等待队列
答:调用await方法的时候(将当前线程构造成一个等待状态为在等待队列中的节点,将节点插入到等待队列的尾部;释放在同步队列中的该节点,并且让该节点可用)。
② 问题:节点什么时候从等待队列转移到同步队列
答:调用signal方法的时候(判断当前等待队列中的头结点不为空,然后获取等待队列的头节点,修改等待状态为在同步队列中,再将节点插入到同步队列的尾部)。


---------------------------该源码为jdk1.7版本的

相关文章

  • AbstractQueuedSynchronizer等待队列源码

    内部实现类ConditionObject的继承与实现关系 常用属性及构造器 实现方法 await()方法:让当前线...

  • AQS

    AQS(AbstractQueuedSynchronizer) node node是等待队列(双向队列)的节点分别...

  • JUC之AbstractQueuedSynchronizer

    1. 前言 AbstractQueuedSynchronizer(AQS)基于FIFO等待队列以及CAS操作实现了...

  • API翻译之AbstractQueuedSynchronizer

    AbstractQueuedSynchronizer   提供一个框架,用于实现依赖先进先出(FIFO)等待队列的...

  • AQS

    AbstractQueuedSynchronizer源码 AbstractQueuedSynchronizer(A...

  • 你了解Java中的同步器框架AQS吗?

    AbstractQueuedSynchronizer 概念 为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和...

  • Java并发编程 -- AQS

    AbstractQueuedSynchronizer是为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同...

  • AQS原理

    AQS(AbstractQueuedSynchronizer)主要用于对资源状的态管理及等待队列的调度。资源的状态...

  • Java-线程安全(AQS)

    AQS源码分析(AbstractQueuedSynchronizer) AQS是一个抽象类,是一个队列同步器。Re...

  • AQS

    AbstractQueuedSynchronizer维护了一个State值和一个FIFO等待队列的框架。可以用来实...

网友评论

      本文标题:AbstractQueuedSynchronizer等待队列源码

      本文链接:https://www.haomeiwen.com/subject/zueriftx.html