详解Java并发之Condition

在使用lock之前，我们使用的最多的同步方式应该是synchronized关键字来实现同步方式了。配合object的wait()、notify()系列方法可以实现等待/通知模式。condition接口也提供了类似object的监视器方法，与lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。object和condition接口的一些对比。摘自《java并发编程的艺术》

一、condition接口介绍和示例

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

package com.ydl.test.juc;

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();
    }
  }

}

pool-1-thread-1拿到锁了
pool-1-thread-1等待信号
pool-1-thread-2拿到锁了
pool-1-thread-2发出信号
pool-1-thread-1拿到信号

如示例所示，一般都会将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() ：造成当前线程在接到信号之前一直处于等待状态。【注意：该方法对中断不敏感】。

awaituntil(date deadline) ：造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知，则返回true，否则表示到了指定时间，返回返回false。

signal() ：唤醒一个等待线程。该线程从等待方法返回前必须获得与condition相关的锁。

signal()all ：唤醒所有等待线程。能够从等待方法返回的线程必须获得与condition相关的锁。

三、condition接口原理简单解析

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

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

       3.2、等待

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

       3.3、通知

调用condition的signal()方法，将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点），在唤醒节点前，会将节点移到同步队列中。当前线程加入到等待队列中如图所示：

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

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

四、总结

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

五、利用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的详细内容，更多关于java并发condition的资料请关注其它相关文章！