多线程的应用与原理分析7（Condition）

文章最前： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人github ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。

相关文章：

1. 多线程的应用与原理分析1
2. 多线程的应用与原理分析2（线程的状态）
3. 多线程的应用与原理分析3（原子性、可见性、有序性）
4. 多线程的应用与原理分析4（synchronized）
5. 多线程的应用与原理分析5（ReentrantLock）
6. 多线程的应用与原理分析6（ReentrantLock）
7. 多线程的应用与原理分析7（Condition）
8. 多线程的应用与原理分析8（countdownlatch）
9. 多线程的应用与原理分析9（原子操作）
10. 多线程的应用与原理分析10（Semaphore）
11. 多线程的应用与原理分析11（线程池）

---

Condition

         通过前面的课程学习，我们知道任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括wait()、notify()以及notifyAll()方法，这些方法与synchronized同步关键字配合，可以实现等待/通知模式；JUC包提供了Condition来对锁进行精准控制，Condition是一个多线程协调通信的工具类，可以让某些线程一起等待某个条件（condition），只有满足条件时，线程才会被唤醒。

condition使用案例
 1. ConditionDemoWait.java

package lock.conditiondemo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author zhangyu
 * @version V1.0
 * @ClassName: ConditionDemoWait
 * @Description: 测试condition
 * @date 2019/1/24 11:20
 **/


public class ConditionDemoWait implements Runnable {
    private Lock lock;
    private Condition condition;

    public ConditionDemoWait(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        System.out.println("begin-ConditionDemoWait");
        try {
            lock.lock();
            condition.await();
            System.out.println("end-ConditionDemoWait");

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 2. ConditionDemoSignal.java

package lock.conditiondemo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author zhangyu
 * @version V1.0
 * @ClassName: ConditionDemoSignal
 * @Description: 测试signal
 * @date 2019/1/24 11:27
 **/


public class ConditionDemoSignal implements Runnable {
    private Lock lock;
    private Condition condition;

    public ConditionDemoSignal(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        System.out.println("begin-ConditionDemoSinal");
        try {
            lock.lock();
            condition.signal();
            System.out.println("end-ConditonDemoSginal");
        } finally {
            lock.unlock();
        }
    }
}

        通过这个案例简单实现了wait和notify的功能，当调用await方法后，当前线程会释放锁并等待，而其他线程调用condition对象的signal或者signalall方法通知并被阻塞的线程，然后自己执行unlock释放锁，被唤醒的线程获得之前的锁继续执行，最后释放锁，所以，condition中两个最重要的方法，一个是await，一个是signal方法。
await:把当前线程阻塞挂起
signal:唤醒阻塞的线程

---

await方法
          调用Condition的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从await()方法返回时，当前线程一定获取了Condition相关联的锁。

 public final void await() throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        Node node = addConditionWaiter(); //创建一个新的节点，节点状态为condition，采用的数据结构仍然是链表
        int savedState = fullyRelease(node); //释放当前的锁，得到锁的状态，并唤醒AQS队列中的一个线程
        int interruptMode = 0;
           //如果当前节点没有在同步队列上，即还没有被signal，则将当前线程阻塞
           //isOnSyncQueue 判断当前 node 状态,如果是 CONDITION 状态,或者不在队列上了,就继续阻塞,还在队列上且不是 CONDITION 状态了, 就结束循环和阻塞
        while (!isOnSyncQueue(node)) {//第一次判断的是false，因为前面已经释放锁了
            LockSupport.park(this); // 第一次总是 park 自己,开始阻塞等待
             // 线程判断自己在等待过程中是否被中断了,如果没有中断,则再次循环,会在 isOnSyncQueue 中判断自己是否在队列上.
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
            }
           // 当这个线程醒来,会尝试拿锁, 当 acquireQueued 返回 false 就是拿到锁了.
           // interruptMode != THROW_IE -> 表示这个线程没有成功将 node 入队,但 signal 执行了 enq 方法让其入队了.
          // 将这个变量设置成 REINTERRUPT.
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        // 如果 node 的下一个等待者不是 null, 则进行清理,清理 Condition 队列上的节点
        // 如果是 null ,就没有什么好清理的了.
        if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
        // 如果线程被中断了,需要抛出异常.或者什么都不做
        if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
    }

signal方法
          调用Condition的signal()方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中。

public final void signal() {
   if (!isHeldExclusively()) //先判断当前线程是否获得了锁
      throw new IllegalMonitorStateException();
      Node first = firstWaiter; // 拿到 Condition 队列上第一个节点
      if (first != null)
      doSignal(first);
}

private void doSignal(Node first) {
   do {
       if ( (firstWaiter = first.nextWaiter) == null)// 如果第一个节点的下一个节点是 null,那 
       么, 最后一个节点也是 null.
      lastWaiter = null; // 将 next 节点设置成 null
      first.nextWaiter = null;
   } while (!transferForSignal(first) &&(first = firstWaiter) != null);
}

该方法先是 CAS 修改了节点状态，如果成功，就将这个节点放到 AQS 队列中，然后唤醒这个节点上的线程。此时，那个节点就会在 await 方法中苏醒。

final boolean transferForSignal(Node node) {
     if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
     return false;
     Node p = enq(node);
     int ws = p.waitStatus;
      // 如果上一个节点的状态被取消了, 或者尝试设置上一个节点的状态为 SIGNAL 失败了(SIGNAL 表示: 他的 next 节点需要停止阻塞),
     if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
     LockSupport.unpark(node.thread); // 唤醒输入节点上的线程.
     return true;
}