J.U.C之Condition

J.U.C之Condition

一、Condition简介

条件队列：它使得一组线程能够通过某种方式来等待特定的条件变成真。传统队列的元素是一个个数据，而与之不同的是，条件队列中的元素时一个个正在等待相关条件的线程。

正如每个Java对象都可以作为一个锁，每个对象同样可以作为一个条件队列，并且Object中的wait、notify和notifyAll方法就构成了内部条件队列的API。对象的内置锁与其内部条件队列是相互关联的，要调用对象X中条件队列的任何一个方法，必须持有对象X上的锁。这是因为“等待由状态构成的条件”与“维护状态一致性”这两种机制必须被紧密地绑定在一起：只有能对状态进行检查时，才能在某个条件上等待，并且只有能修改状态时，才能从条件等待中释放另一个线程。

内置的条件队列有一个缺陷：每个内置锁都只能有一个相关联的条件队列，多个线程可能在同一个条件队列上等待不同的条件谓词，并且在最常见的加锁模式下公开条件队列对象。这些因素都使得无法满足在使用notifyAll时所有等待线程为同一类型的需求。如果想编写一个带有多个条件谓词的并发对象，或者想获得除了条件队列可见性之外的更多控制权，就可以使用显示的Lock和Condition而不是内置锁和条件队列，这是一种更灵活的选择。

一个Condition和一个Lock关联在一起，就像一个条件队列和一个内置锁相关联一样。要创建一个Condition，可以在相关联的Lock上调用Lock.newcondition方法。正如Lock比内置加锁提供了更为丰富的功能，condition同样比内置条件队列提供了更丰富的功能：在每个锁上可存在多个等待、条件等待可以是中断的或不可中断的、基于时限的等待，以及公平的或非公平的队列操作。

与内置条件队列不同的是，对于每个Lock，可以有任意数量的Condition对象。Condition对象继承了相关的Lock对象的公平性，对于公平的锁，线程会依照FIFO顺序从Condition.await中释放。

Condition对象中，与wait、notify，notifyAll对应的分别是await、signal、signall。

二、实例

还是生产者-消费者模型：

package com.mylearn.thread.lock; import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /**  * Created by IntelliJ IDEA.  * User: yingkh  * Date: 12-12-24  * Time: 下午2:14  * CopyRight:360buy  * Descrption:  生产者消费者  * To change this template use File | Settings | File Templates.  */ public class ConditionTest2 {     public static void main(String args[]) throws InterruptedException {         for(int i = 0 ;i < 5; i++) {                 new Thread(new Product()).start();         }         Thread.sleep(1000);         for(int i = 0 ;i < 15; i++) {             new Thread(new Consumer()).start();             new Thread(new Product()).start();             Thread.sleep(1000);         }     } } class GlobalRule {     public final static Lock lock = new ReentrantLock();     public final static Condition notEmpty = lock.newCondition();     public final static Condition notFull = lock.newCondition();     public final static List<String> array = new ArrayList<String>(3);  //临界区 } class Consumer implements Runnable {     public void run() {         GlobalRule.lock.lock();         try {             while (GlobalRule.array.size() <= 0) { //条件谓词                 try {                     GlobalRule.notEmpty.await();                     System.out.println("临界区空了，等待生产者放入东西！");                     Thread.sleep(100);                 } catch (InterruptedException e) {                     e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.                 }             }             System.out.println("消费者消费了一个食物：" + GlobalRule.array.get(0));   //消费食物             GlobalRule.notFull.signalAll();    //唤醒生产者，告诉他们临界区没满，可以生产食物了         } finally {             GlobalRule.lock.unlock();         }     } } class Product implements Runnable{     public void run() {         GlobalRule.lock.lock();         try{             while(GlobalRule.array.size() >=3) {//条件谓词                 try {                     GlobalRule.notFull.await();                     System.out.println("临界区满了，等待消费者取出东西！");                     Thread.sleep(100);                 } catch (InterruptedException e) {                     e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.                 }             }             GlobalRule.array.add("a!delicious food!");  //放入食物             System.out.println("生产者往临界区放了一个食物");             GlobalRule.notEmpty.signalAll();  //唤醒消费者，让他们临界区非空了，可以消费，         } finally {             GlobalRule.lock.unlock();         }     } }

三、总结：

在使用显式的Condition和内置条件队列之间进行选择时，与在ReentrantLock和synchronized之间进行选择是一样的：如果需要一些高级功能，例如使用公平的队列操作或者在每个锁上对应多个等待线程集，那么应该优先使用Condition而不是内置条件队列。