Condition源码解析

简介：
最近因为找工作的原因，博客也是断更了好久，现在继续，接着上篇文章的ReentrantLock继续看Condition。

UML图：
属性：
构造方法：
上面的都没啥好说的，直接看常用方法吧。
await()：

public final void await() throws InterruptedException {
            //ReentrantLock是可中断锁的代码
            if (Thread.interrupted())
                throw new InterruptedException();
            //将当前线程加入等待队列，且清除所有不是CONDITION的节点
            Node node = addConditionWaiter();
            //释放当前线程的锁，将state改成0
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            //判断是不是CONDITION状态，或者在等待队列还是同步队列里面
            while (!isOnSyncQueue(node)) {
                //阻塞
                LockSupport.park(this);
                //醒了之后先检查下线程的中断状态，因为唤醒了要么是signal，要么是被中断的
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //走到这，说明肯定是被唤醒了，再去获取锁
            //interruptMode其实就是判断的是否被中断过，在signal之前还是之后中断的
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                //清除所有不是CONDITION状态的节点d
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                //判断下是否要抛异常
                reportInterruptAfterWait(interruptMode);
        }

大致的注释都有，下面分析一下里面的具体的方法实现：
addConditionWaiter()：

        private Node addConditionWaiter() {
            Node t = lastWaiter;
            //如果尾节点不是CONDITION状态，全部清除
            if (t != null && t.waitStatus != Node.CONDITION) {
                //清除所有不是CONDITION状态的节点
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            //新的节点，状态就是CONDITION
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

addConditionWaiter主要就是做的就是将新节点加入到等待队列，顺便清除不是CONDITION状态的节点。
unlinkCancelledWaiters()：

        private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            //遍历
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    //不是CONDITION状态就把nextWaiter置为null
                    t.nextWaiter = null;
                    if (trail == null)
                        //trail为null说明头节点就不是CONDITION状态
                        //就把头节点改成当前节点的下一个
                        firstWaiter = next;
                    else
                        //此时的trail相当于全是CONDITION状态的队列的尾节点
                        trail.nextWaiter = next;
                    if (next == null)
                        //如果是最后一个，就把尾节点改成trail
                        lastWaiter = trail;
                }
                else
                    //当前节点是CONDITION状态就记住这个节点
                    //仔细想一下，trail一直是目前遍历的节点是CONDITION状态的最后一个
                    trail = t;
                t = next;
            }
        }

unlinkCancelledWaiters主要就是从头开始遍历，把状态是CONDITION的置为null，移除掉。
fullyRelease(node)：

    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            int savedState = getState();
            //将锁的次数传入
            if (release(savedState)) {
                //state置0成功
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                //如果失败，将当前节点的状态改成取消状态
                node.waitStatus = Node.CANCELLED;
        }
    }

fullyRelease主要就是释放锁。
isOnSyncQueue(node)：

    final boolean isOnSyncQueue(Node node) {
        //判断当前节点的状态是否是CONDITION状态，是的话证明在等待队列里面
        //或者前驱是否为null，为null的话也代表在等待队列里面，因为等待队列是单向链表
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        //如果节点状态不是等待状态，且后驱有值，说明已经在同步队列里面了
        if (node.next != null)
            return true;
        //走到这，node应该就是tail，从同步队列的tail开始往前找
        return findNodeFromTail(node);
    }
    private boolean findNodeFromTail(Node node) {
        Node t = tail;
        for (;;) {
            if (t == node)
                //找到就返回true
                return true;
            if (t == null)
                //到最前面也找不到就返回false
                return false;
            //一直往前找
            t = t.prev;
        }
    }

isOnSyncQueue主要就是判断现在是不是在等待队列里面，在的话就阻塞等待。
acquireQueued就是获取锁，在讲ReentrantLock的文章分析过了。

signal()：

        public final void signal() {
            //判断当前线程是否是抢到锁的线程
            if (!isHeldExclusively())
                //不是的话要抛异常，因为
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                //取等待队列的第一个节点
                doSignal(first);
        }

doSignal(first)：

        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    //如果first后面没有了，就把lastWaiter也置为null
                    lastWaiter = null;
                //把后驱置为null，相当于从等待队列里面移除了
                first.nextWaiter = null;
            //试唤醒当前节点，
            // 如果唤醒失败，则继续尝试唤醒当前节点的后继节点。
        } while (!transferForSignal(first) &&
                    (first = firstWaiter) != null);
        }

doSignal主要就是取等待队列的第一个节点，并从等待队列移除。
transferForSignal(first)：

    final boolean transferForSignal(Node node) {

        //用CAS的方式更新当前节点的状态，从CONDITION更新成0
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            //失败说明当前节点已经不是CONDITION状态了，返回false
            return false;

        //更新成功了就把当前节点加入到同步队列
        Node p = enq(node);
        int ws = p.waitStatus;
        //ws > 0说明节点是CANCELLED状态
        //或者把节点的状态更新成SIGNAL失败
        //满足上述2个条件的其中一个，就会调用unpark
        //有没有感觉很奇怪?为啥不直接unpark呢?因为节点状态如果是SIGNAL状态，会自动唤醒next节点
        //而同步队列里面的节点都是SIGNAL状态的，所以只有不是SIGNAL状态的，这里才主动unpark。
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }

这里呢，就跟ReentrantLock呼应起来了，signal方法并不是直接去unpark线程的。正常情况下，是由被唤醒的线程主动去唤醒自己身后的节点的。具体可以看下本人ReentrantLock 的文章。

到这差不多就结束了，下篇分析LinkedBlockingQueue。