Condition

1、Condition的简介

线程通信中的互斥除了用synchronized、Object类的wait()和notify()/notifyAll()方式实现外，方法JDK1.5中提供的Condition配套Lock可以实现相同的功能。Condition中的await()和signal()/signalAll()就相当于Object的wait()和notify()/notifyAll()。传统线程的通信方式，Condition都可以实现。不过要注意的是，Condition是被绑定到Lock上的，所以要创建一个Lock的Condition必须使用newCondition()方法。在等待Condition时，允许发生“虚假唤醒”， 这通常作为对基础平台语义的让步。

Condition的强大之处在于它可以为多个线程间建立不同的Condition。

2、Condition源码中的例子

看JDK文档中的一个例子：假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存put 线程和take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个Condition实例来做到这一点。

——其实就是java.util.concurrent.ArrayBlockingQueue的功能。

class BoundedBuffer {  final Lock lock = new ReentrantLock();          //锁对象  final Condition notFull  = lock.newCondition(); //写线程锁  final Condition notEmpty = lock.newCondition(); //读线程锁  final Object[] items = new Object[100];//缓存队列  int putptr;  //写索引  int takeptr; //读索引  int count;   //队列中数据数目  //写  public void put(Object x) throws InterruptedException {  lock.lock(); //锁定  try {  // 如果队列满，则阻塞<写线程>  while (count == items.length) {  notFull.await();   }  // 写入队列，并更新写索引  items[putptr] = x;   if (++putptr == items.length) putptr = 0;   ++count;  // 唤醒<读线程>  notEmpty.signal();   } finally {   lock.unlock();//解除锁定   }   }  //读   public Object take() throws InterruptedException {   lock.lock(); //锁定   try {  // 如果队列空，则阻塞<读线程>  while (count == 0) {  notEmpty.await();  }  //读取队列，并更新读索引  Object x = items[takeptr];   if (++takeptr == items.length) takeptr = 0;  --count;  // 唤醒<写线程>  notFull.signal();   return x;   } finally {   lock.unlock();//解除锁定   }   }   

3、Condition demo

1）demo 1

接着上次（子线程和主线程依次轮流循环50的多线程面试题）的一道面试题，现在改用Condition和Lock来实现：

/*** 面试题目：子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着又回到主线程又循环100次，如此循环50次。写出程序* * 经验：要用到共同数据（包括同步锁）或共同算法的若干个方法应该归在同一个类身上，这种设计体现了高类聚和程序的健壮性。* * 采用condition通信方式：Condition的功能类似在传统线程技术中的Object.wait()和Object.notify的功能。* 在等待Condition时，允许发生“虚假唤醒”。*/
public class ConditionCommunication {public static void main(String[] args) {final Business business = new Business();// 子线程循环new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 50; i++) {try {business.sub(i);} catch (InterruptedException e) {}}}}).start();// 主线程循环for (int i = 1; i <= 50; i++) {try {business.mian(i);} catch (InterruptedException e) {}}}/*** 业务类型（包含各色的同步锁）*/static class Business {Lock lock = new ReentrantLock();Condition condition = lock.newCondition();// sub()方法是否该运行标识private boolean bShouldSub = true;/*** 循环100次打印的方法sub()* * @param i* @throws InterruptedException*/public void sub(int i) throws InterruptedException {lock.lock();try {while (!bShouldSub) { // 当 bShouldSub 为 false 时，则等待condition.await(); // 不能写成condition.wait();，这里的wait()是Object的方法}for (int j = 1; j <= 10; j++) {System.out.println("sub thread :   第" + i + "行， 第" + j + "列");}bShouldSub = false; // 执行for循环后，标志sub()方法不可再执行condition.signal(); // 发信号} finally {lock.unlock();}}/*** 循环100次打印的方法mian()* * @param i* @throws InterruptedException*/public void mian(int i) throws InterruptedException {lock.lock();try {while (bShouldSub) {condition.await(); // 不能写成condition.wait();，这里的wait()是Object的方法}for (int j = 1; j <= 100; j++) {System.out.println("main thread :   第" + i + "行， 第" + j + "列");}bShouldSub = true; // 执行for循环后，标志sub()方法可再执行了condition.signal(); // 发信号} finally {lock.unlock();}}}
}

2)demo 2

用上面的demo1题目改装为：线程1循环10次，接着线程2循环20次，接着线程3循环30次，又回到线程1循环10次，接着又回到线程2循环20次……，如此循环50次。

分析：这种实现顺序唤醒的，可以采用创建多个Condition来实现。

写出程序：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** 面试题目：线程1循环10次，接着线程2循环20次，接着线程3循环30次，又回到线程1循环10次，接着又回到线程2循环20次……，如此循环50次。写出程序*/
public class ConditionCommunication2 {public static void main(String[] args) {final Business business = new Business();// 线程2循环sub2()new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 50; i++) {try {business.sub2(i);} catch (InterruptedException e) {}}}}).start();// 线程3循环sub3()new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 50; i++) {try {business.sub3(i);} catch (InterruptedException e) {}}}}).start();// （主线程）线程1循环sub1()for (int i = 1; i <= 50; i++) {try {business.sub1(i);} catch (InterruptedException e) {}}}/*** 业务类型（包含各色的同步锁）*/static class Business {Lock lock = new ReentrantLock();Condition condition1 = lock.newCondition();Condition condition2 = lock.newCondition();Condition condition3 = lock.newCondition();// sub()方法是否该运行标识private int shouldSub = 1;/*** 循环10次打印的方法sub1()* * @param i* @throws InterruptedException*/public void sub1(int i) throws InterruptedException {lock.lock();try {while (shouldSub != 1) {  // 当 shouldSub 不为 1 时，则等待condition1.await(); // 不能写成condition.wait();，这里的wait()是Object的方法}for (int j = 1; j <= 10; j++) {System.out.println("sub1 thread :   第" + i + "行， 第" + j + "列");}shouldSub = 2; // 执行for循环后，标志下一个可以循环的方法时sub2()condition2.signal(); // condition2发信号} finally {lock.unlock();}}/*** 循环20次打印的方法sub2()* * @param i* @throws InterruptedException*/public void sub2(int i) throws InterruptedException {lock.lock();try {while (shouldSub != 2) {  // 当 shouldSub 不为 2 时，则等待condition2.await(); // 不能写成condition.wait();，这里的wait()是Object的方法}for (int j = 1; j <= 20; j++) {System.out.println("sub2 thread :   第" + i + "行， 第" + j + "列");}shouldSub = 3; // 执行for循环后，标志下一个可以循环的方法时sub3()condition3.signal(); // condition3发信号} finally {lock.unlock();}}/*** 循环30次打印的方法sub3()* * @param i* @throws InterruptedException*/public void sub3(int i) throws InterruptedException {lock.lock();try {while (shouldSub != 3) {  // 当 shouldSub 不为 3时，则等待condition3.await(); // 不能写成condition.wait();，这里的wait()是Object的方法}for (int j = 1; j <= 30; j++) {System.out.println("sub3 thread :   第" + i + "行， 第" + j + "列");}shouldSub = 1; // 执行for循环后，标志下一个可以循环的方法时sub1()condition1.signal(); // condition1发信号} finally {lock.unlock();}}}
}