Java并发之Condition

一、简介

在使用Lock之前，我们使用的 最多的同步方式 应该是 synchronized 关键字来 实现同步 。配合 Object 的 wait() 、 notify() 系列方法可以 实现等待/通知模式 。 Condition 接口也提供了类似 Object 的监视器方式，与 Lock 配合可以 实现等待/通知模式 ，但是这两者在使用方式以及功能特性上还有有差别的。

Object和Condition接口 的一些对比。摘自《Java并发编程的艺术》

二、Condition接口介绍和示例

首先我们需要明白 Condition 对象是 依赖于 lock 对象的，意思就是说 condition 对象需要通过 lock 对象进行 创建 出来（调用 Lock 对象的 newCondition() 方法），condition的使用方法非常简单，但是需要 注意在调用方法前获取锁 。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionUseCase {

    public Lock lock = new ReentrantLock();
    public Condition condition = lock.newCondition();

    public static void main(String[] args)  {
        ConditionUseCase useCase = new ConditionUseCase();
        ExecutorService executorService = Executors.newFixedThreadPool (2);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                useCase.conditionWait();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                useCase.conditionSignal();
            }
        });
    }

    public void conditionWait()  {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "拿到锁了");
            System.out.println(Thread.currentThread().getName() + "等待信号");
            condition.await();
            System.out.println(Thread.currentThread().getName() + "拿到信号");
        }catch (Exception e){

        }finally {
            lock.unlock();
        }
    }
    public void conditionSignal() {
        lock.lock();
        try {
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName() + "拿到锁了");
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "发出信号");
        }catch (Exception e){

        }finally {
            lock.unlock();
        }
    }

}
复制代码

运行结果如下：

如示例所示，一般都会将Condition对象作为成员变量。当调用 await() 方法后， 当前线程 会 释放锁并在此等待 ，而其他线程调用Condition对象的 signal() 方法， 通知当前线程 后， 当前线程 才从 await() 方法 返回 ，并且在返回前 已经获取了锁 。

三、Condition接口常用方法

condition可以通俗的理解为条件队列。当一个线程在调用了await()方法以后，知道线程等待的某个条件为真的时候才会被唤醒。这种方式为线程提供了更加简单的等待/通知模式。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。

• await() ：造成当前线程在接到信号或被中断之前一直处于等待状态

• await(long time, TimeUnit unit) ：造成当前线程在 接到信号、被中断或到达指定等待时间 之前一直处于等待状态
• awaitNanos(long nanosTimeout) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在 nanosTimesout 之前 唤醒 ，那么 返回值 = nanosTimeout - 消耗时间 ，如果 返回值 <= 0 ，则可以 认定它超时
• awaitUninterruptibly() ：造成当前线程在 接到信号之前一直处于等待状态 。【注意：该方法对中断不敏感】
• awaitUnit(Date deadline) ：造成当前线程在 接到信号，被中断或者到达指定最后期限 之前一直处于 等待状态 。如果 没有到指定时间就被通知 ，则返回 true ， 否则 表示到了指定时间，返回 false 。
• signal() ： 唤醒一个等待线程 。该线程从等待方法返回前必须获得与Condition相关的锁。
• signalAll() ： 唤醒所有等待线程 ，能够从等待方法返回的线程必须获得与Condition相关的锁。

四、Condition接口原理简单分析

1、插入等待线程

Condition 是 AQS 的 内部类 。每个 Condition对象 都包含一个队列（ 等待队列 ）。等待队列是一个 FIFO 的队列，在队列中的 每个节点 都包含了 一个线程引用 ，该线程就是在Condition对象上等待的线程，如果一个新出调用了Condition.await()方法，那么该线程将会 释放锁 、 构造成节点加入等待队列 并进入 等待状态 。等待队列的基本结构如下所示：

等待分为首节点和尾节点。当一个线程调用Condition.await()方法，将会以当前节点构造节点，并将节点从尾部加入等待队列。新增节点就是将尾部节点指向新增节点。 节点引用更新 本来就是在 获取锁 以后的操作，所以 不需要CAS保证 。同时也是 线程安全 的操作。

2、等待

当线程调用了 await() 方法之后， 线程 就作为 队列中的一个节点被加入到等待队列 中，同时会 释放锁的拥有 。当从 await()方法返回 时， 一定 会获取 condition相关联的锁 。当等待队列中的节点被唤醒时，则唤醒节点的线程开始尝试获取同步状态。如果不是通过其他线程掉员工Condition.signal()方法唤醒，而是对等待线程进行唤醒，则会抛出InterruptedException异常信息。

3、通知

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

当前线程加入到等待队列 中如图所示：

在调用 signal()方法之前 必须先 判断是否获取到了锁 。接着 获取等待队列的首节点 ，将其移动到 同步队列 并利用 LockSupport 唤醒节点中的线程 。节点从等待队列移动到同步队列，如下图所示：

被唤醒的线程将从 await() 方法中的 while循环 中退出。随后加入到 同步状态 的竞争中去。成功获取到竞争的线程则会返回到await()方法之前的状态。

五、总结

调用await()方法，将当前线程加入Condition等待队列中，当前线程释放锁，否则别的线程将无法拿到锁而发生死锁。 自旋（while）挂起 ，不断检测 节点是否在同步队列 中，如果是则尝试获取锁，否则挂起。当前线程被signal()方法唤醒，被唤醒的线程将从await()方法中的while循环中退出来，然后调用 acquireQueue() 方法竞争同步状态。

六、利用Condition实现生产者消费者模式

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

public class BoundedQueue {

    private LinkedList<Object> buffer;    //生产者容器
    private int maxSize ;           //容器最大值是多少
    private Lock lock;
    private Condition fullCondition;
    private Condition notFullCondition;
    BoundedQueue(int maxSize){
        this.maxSize = maxSize;
        buffer = new LinkedList<Object>();
        lock = new ReentrantLock();
        fullCondition = lock.newCondition();
        notFullCondition = lock.newCondition();
    }

    /**
     * 生产者
     * @param obj
     * @throws InterruptedException
     */
    public void put(Object obj) throws InterruptedException {
        lock.lock();    //获取锁
        try {
            while (maxSize == buffer.size()){
                notFullCondition.await();       //满了，添加的线程进入等待状态
            }
            buffer.add(obj);
            fullCondition.signal(); //通知
        } finally {
            lock.unlock();
        }
    }

    /**
     * 消费者
     * @return
     * @throws InterruptedException
     */
    public Object get() throws InterruptedException {
        Object obj;
        lock.lock();
        try {
            while (buffer.size() == 0){ //队列中没有数据了 线程进入等待状态
                fullCondition.await();
            }
            obj = buffer.poll();
            notFullCondition.signal(); //通知
        } finally {
            lock.unlock();
        }
        return obj;
    }

}
复制代码

内容来源： Java并发之Condition