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

我会带着你远行 2022-04-23 05:32 159阅读 0赞

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

**相关文章：**

1.  [多线程的应用与原理分析1][1]
2.  [多线程的应用与原理分析2（线程的状态）][2]
3.  [多线程的应用与原理分析3（原子性、可见性、有序性）][3]
4.  [多线程的应用与原理分析4（synchronized）][4_synchronized]
5.  [多线程的应用与原理分析5（ReentrantLock）][5_ReentrantLock]
6.  [多线程的应用与原理分析6（ReentrantLock）][6_ReentrantLock]
7.  [多线程的应用与原理分析7（Condition）][7_Condition]
8.  [多线程的应用与原理分析8（countdownlatch）][8_countdownlatch]
9.  [多线程的应用与原理分析9（原子操作）][9]
10. [多线程的应用与原理分析10（Semaphore）][10_Semaphore]
11. [多线程的应用与原理分析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;
    }

[github]: https://github.com/zhangyu345293721
[1]: https://blog.csdn.net/zy345293721/article/details/86565631
[2]: https://blog.csdn.net/zy345293721/article/details/86583663
[3]: https://blog.csdn.net/zy345293721/article/details/86596268
[4_synchronized]: https://blog.csdn.net/zy345293721/article/details/86607632
[5_ReentrantLock]: https://blog.csdn.net/zy345293721/article/details/86617801
[6_ReentrantLock]: https://blog.csdn.net/zy345293721/article/details/86621392
[7_Condition]: https://blog.csdn.net/zy345293721/article/details/86622891
[8_countdownlatch]: https://blog.csdn.net/zy345293721/article/details/86636846
[9]: https://blog.csdn.net/zy345293721/article/details/86645245
[10_Semaphore]: https://blog.csdn.net/zy345293721/article/details/86644996
[11]: https://blog.csdn.net/zy345293721/article/details/86646019