Java8 ConditionObject 源码解析

   目录

1、定义

         2、使用

3、await / awaitUninterruptibly

4、await / awaitNanos / awaitUntil

5、signal / signalAll

6、其他方法实现总结

---

      上一篇《Java8 ReentrantLock 源码解析》中主要讲解了lock和unlock相关方法的实现，本篇讲解ReentrantLock的newCondition方法返回的ConditionObject实例的使用和实现细节。

1、定义

     ConditionObject是AbstractQueuedSynchronizer的一个内部类，用于实现Condition接口，ReentrantLock通过newCondition方法返回该类的一个实例，如下：

public Condition newCondition() {
        return sync.newCondition();
}

 final ConditionObject newCondition() {
            return new ConditionObject();
        }

Condition接口定义的方法如下：

这里的await相当于Object的wait方法，signal和signalAll方法相当于Object的notify和notifyAll方法。concurrent包下各种阻塞队列和线程池等就是Condition接口实现阻塞，以await方法的调用链为例说明，如下：

  ConditionObject只有两个属性：

• private transient Node firstWaiter; //在某个Condition实例上等待的Node链表的链表头，即调用了某个condition实例的await方法的等待线程链表
• private transient Node lastWaiter; //在某个Condition实例上等待的Node链表的链表尾

   注意上述链表是通过Node的nextWaiter构成的单向链表，跟通过Node的prev，next属性构成的等待获取锁的同步链表是不一样的，后者的链表头和链表为分别是AbstractQueuedSynchronizer的head和tail属性。

    ConditionObject还定义了两个常量，描述await方法退出时的处理方式，如下：

REINTERRUPT表示将当前线程的中断标识重置为true，因为之前获取线程是否中断时，会将线程的中断标识给清除掉重置为false，此处是为了还原；THROW_IE表示会抛出一个InterruptedException异常，表示当前线程被唤醒是因为被中断了。 

2、使用

     ConditionObject的await系列方法相当于Object的wait方法，signal和signalAll方法分别对应于Object的notify和notifyAll方法，跟Object一样，执行这些方法前都需要检查当前线程是否持有锁，如果没有持有则会抛出IllegalMonitorStateException异常，ConditionObject的方法和Object的对应方法的实现逻辑也大体一致，参考如下测试用例：

@Test
    public void name2() throws Exception {
        Object lock = new Object();
        Runnable a = new Runnable() {
            @Override
            public void run() {

                try {
                    System.out.println("run start,time->" + System.currentTimeMillis());
                    Thread.sleep(6000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (lock) {
                    lock.notify();
                    System.out.println("run end");
                }
            }
        };
        Thread thread = new Thread(a);
        thread.start();
        synchronized (lock) {
            System.out.println("main start,time->" + System.currentTimeMillis());
            long start = System.currentTimeMillis();
            lock.wait(1000);
            System.out.println("wait time->" + (System.currentTimeMillis() - start));
        }
        System.out.println("main end");
    }

    @Test
    public void name3() throws Exception {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Runnable a = new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    System.out.println("run start,time->" + System.currentTimeMillis());
                    Thread.sleep(6000);
                    condition.signal();
                    System.out.println("run end");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        };
        Thread thread = new Thread(a);
        lock.lock();
        try {
            thread.start();
            System.out.println("main start,time->" + System.currentTimeMillis());
            long start = System.currentTimeMillis();
            condition.await(1, TimeUnit.SECONDS);
            System.out.println("wait time->" + (System.currentTimeMillis() - start));
        } finally {
            lock.unlock();
        }
        System.out.println("main end");
    }

这两个的执行结果一样，如下：

main start,time->1585901311285
run start,time->1585901311286
run end
wait time->6001
main end

wait方法明明最多等待1s，为啥实际等待了6s了，难道是1s后没有被唤醒？答案是调用await和wait方法都会释放当前占有的锁，然后阻塞当前线程；1s过了，阻塞的线程被唤醒了，因为await和wait方法后面的逻辑处于加锁的代码块中，所以线程被唤醒后需要重新去抢占锁，此时锁是被线程thread占用的，所以线程会被唤醒后尝试获取失败又继续被阻塞了，直到6s后thread线程释放锁并唤醒阻塞的main线程，main线程重新获取锁成功，才从await或者wait方法退出，执行下面的逻辑。

3、await / awaitUninterruptibly

     await方法用于让当前线程阻塞，直到被唤醒或者被打断，如果被打断则抛出异常InterruptedException，awaitUninterruptibly会一直等待直到被唤醒，被打断时不会抛出异常，可以通过线程的中断标识判断是否因为中断被唤醒的，注意无论是被signal唤醒的还是被中断唤醒的，都需要再次获取锁才可以退出await方法。

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        //如果线程已中断抛出异常
        throw new InterruptedException();
    //在ConditionWaiter链表末尾插入一个新的状态是CONDITION的节点    
    Node node = addConditionWaiter();
    //释放占有的锁，并唤醒同步队列中下一个等待节点，如果当前线程未持有锁则抛出异常
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //isOnSyncQueue判断node是否在等待获取锁的同步链表中，对于刚创建的ConditionWaiter节点，没有将其加入到等待获取锁的同步链表中
   //只是将其加入到通过nextWaiter属性维护的等待链表中了，该方法返回false
   //等该节点被signal方法唤醒后就会将其加入到同步链表中了，该方法返回true
    while (!isOnSyncQueue(node)) {
        //执行park让这个线程处于阻塞状态
        LockSupport.park(this);
        //线程被唤醒了，如果线程被中断的话，checkInterruptWhileWaiting的返回值就不是0，此时会退出循环，checkInterruptWhileWaiting在执行时会将当前节点加入到同步链表中
        //如果不是被中断，则继续while循环
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //acquireQueued方法会尝试获取锁，如果失败则阻塞当前线程直到获取成功，返回值为true，表示最后一次唤醒是因为线程中断
    //interruptMode为0或者REINTERRUPT
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        //从链表中移除所有非CONDITION的节点
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

public final void awaitUninterruptibly() {
            //添加一个新的节点
            Node node = addConditionWaiter();
            //释放锁
            int savedState = fullyRelease(node);
            boolean interrupted = false;
            //判断node是否在同步链表中
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                //如果线程被中断过将interrupted 置为true，此时会继续循环，直到被唤醒，node加入到同步链表中，while循环退出
                if (Thread.interrupted())
                    interrupted = true;
            }
            //如果获取锁成功或者interrupted为true，将当前线程标记为已中断
            if (acquireQu