Concurrency Utilities 并发处理（2）Condition 条件变量

Condition 条件变量
条件变量是线程同步对象中的一种，主要用来等待某种条件的发生，条件发生后，可以唤醒等待在该条件上的一个线程，或所有线程。条件变量要与锁一起协同工作。
条件变量调用Lock.newCondition()获得一个实例：
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
通常的调用方式如下：
// 当条件 con == true 时等待
lock.lock();
try {
    if (con == true) {
        condition.await();
    }
    // do something
} finally {
    lock.unlock();
}
// 条件变量的唤醒：
condition.signal(); //唤醒等待的其中一个线程
condition.signalAll(); //唤醒等待的所有线程
条件变量类似JDK1.4或以前版本中的 Object.wait(); Object.notify(); Object.notifyAll();
值得注意的是当condition.await()时，隐式的将条件变量关联的Lock解锁，而使其他线程有机会获得Lock，而检查条件，并在条件满足时，等待在条件变量上。
我们先来看一下没有条件变量时，传统的处理方式：
下面这个例子，创建3个等候线程，每个线程循环调用event.wait(), 等到了event后，显示相应的信息。
然后创建1个通知线程，每隔1秒调用 event.notify() 通知等待线程。
import java.util.Calendar;
public class TestWait {
 // 创建event Object，以使用它的wait(), notify()等方法
 private Object event = null;
 
 public TestWait() {
  // 创建event
  event = new Object();
 }
 
 public static void main(String[] args) {
  TestWait tester = new TestWait();
  
  tester.test();
 }
 public Object getEvent() {
  return event;
 }
 
 public void test() {
  // 启动3个等候线程
  new Thread(new WaitThread(this)).start();
  new Thread(new WaitThread(this)).start();
  new Thread(new WaitThread(this)).start();
  
  // 启动通知线程
  new Thread(new NotifyThread(this)).start();
 }
}
class WaitThread implements Runnable {
 
 private TestWait tester = null;
 
 public WaitThread(TestWait tester) {
  this.tester = tester;
 }
 
 public void run() {
  Calendar now = Calendar.getInstance();
  
  System.out.println(now.getTime() + " W " + Thread.currentThread() + " wait for event.");
  
  while (true) {
   
   try {
    // 同步访问 event
    synchronized (tester.getEvent()) {
     // 等待在 event 上 
     tester.getEvent().wait();
    }
    
    // 等到 event 后，显示信息 "got event"
    Calendar now1 = Calendar.getInstance();
    System.out.println(now1.getTime() + " W " + Thread.currentThread() + " got event.");
    // do something ...
    Thread.sleep(500);
   } catch (Exception e) {
    e.printStackTrace(); 
   }
  }
 }
}
class NotifyThread implements Runnable {
 
 private TestWait tester = null;
 
 public NotifyThread(TestWait tester) {
  this.tester = tester;
 }
 
 public void run() {
  
  while (true) {
   
   try {
    // 间隔1秒
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   
   // 同步访问 event
   synchronized (tester.getEvent()) {
    // 通知等在event上的一个线程
    tester.getEvent().notify();
    // 通知等在event上的所有线程
    // tester.getEvent().notifyAll();
       
    // 打印 "fire event" 信息。
    Calendar now = Calendar.getInstance();
    System.out.println(now.getTime() + " N " + Thread.currentThread() + " fire event.");
   }
  }
 }
}
程序运行结果如下：

Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-0,5,main] wait for event.
Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-2,5,main] wait for event.
Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-1,5,main] wait for event.
Tue Jan 24 14:42:31 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-0,5,main] got event.
Tue Jan 24 14:42:32 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 14:42:32 CST 2006 W Thread[Thread-2,5,main] got event.
Tue Jan 24 14:42:33 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 14:42:33 CST 2006 W Thread[Thread-1,5,main] got event.
Tue Jan 24 14:42:34 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 14:42:34 CST 2006 W Thread[Thread-0,5,main] got event.
Tue Jan 24 14:42:36 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 14:42:36 CST 2006 W Thread[Thread-2,5,main] got event.

前三行启动3个等候线程，线程阻塞在 event.wait()上。
第四行通知线程Thread-3，调用event.notify(); 
第五行Thread-0线程，got event.
一秒钟后，Thread-3,又触发了event.notify();

下面将NotifyThread中的 event.notify(); 改为event.notifyAll(); 看一下运行结果：

Tue Jan 24 15:25:43 CST 2006 W Thread[Thread-1,5,main] wait for event.
Tue Jan 24 15:25:43 CST 2006 W Thread[Thread-2,5,main] wait for event.
Tue Jan 24 15:25:43 CST 2006 W Thread[Thread-0,5,main] wait for event.
Tue Jan 24 15:25:44 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 15:25:44 CST 2006 W Thread[Thread-1,5,main] got event.
Tue Jan 24 15:25:44 CST 2006 W Thread[Thread-0,5,main] got event.
Tue Jan 24 15:25:44 CST 2006 W Thread[Thread-2,5,main] got event.
Tue Jan 24 15:25:45 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 15:25:45 CST 2006 W Thread[Thread-0,5,main] got event.
Tue Jan 24 15:25:45 CST 2006 W Thread[Thread-1,5,main] got event.
Tue Jan 24 15:25:45 CST 2006 W Thread[Thread-2,5,main] got event.
Tue Jan 24 15:25:46 CST 2006 N Thread[Thread-3,5,main] fire event.
Tue Jan 24 15:25:46 CST 2006 W Thread[Thread-1,5,main] got event.
Tue Jan 24 15:25:46 CST 2006 W Thread[Thread-0,5,main] got event.
Tue Jan 24 15:25:46 CST 2006 W Thread[Thread-2,5,main] got event.

可以看到当Thread-3,event.notifyAll(); 所有的线程都 got event.


接下来，我们将这个例子改写为使用条件变量的例子：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class TestCondition {
 private ReentrantLock lock = null;
 private Condition condition = null;
 
 public TestCondition() {
  lock = new ReentrantLock();
  condition = lock.newCondition();
 }

 public static void main(String[] args) {
  
  TestCondition tester = new TestCondition();
  tester.test();
 }
 
 public void test() {
  new Thread(new WaitThread1(this)).start();
  new Thread(new WaitThread1(this)).start();
  new Thread(new WaitThread1(this)).start();
  new Thread(new NotifyThread1(this)).start();
 }
 public ReentrantLock getLock() {
  return lock;
 }
 
 public Condition getCondition() {
  return condition;
 }
}
class NotifyThread1 implements Runnable {
 
 private TestCondition tester = null;
 
 public NotifyThread1(TestCondition tester) {
  this.tester = tester;
 }
 
 public void run() {
  while (true) {
   try {
    Thread.sleep(2000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   
   tester.getLock().lock();
   
   tester.getCondition().signal();
   System.out.println(Thread.currentThread() + " condition signal.");
   
   tester.getLock().unlock();
  }
 }
}
class WaitThread1 implements Runnable {
 
 private TestCondition tester = null;
 
 public WaitThread1(TestCondition tester) {
  this.tester = tester;
 }
 
 public void run() {
  System.out.println(Thread.currentThread() + " started.");
  while (true) {
   tester.getLock().lock();
   try {
    // getCondition().await() 将使getLock()解锁，以便其他线程可以进入 await();
    tester.getCondition().await();
    System.out.println(Thread.currentThread() + " get condition.");
   } catch (InterruptedException e) {
    e.printStackTrace();
   } finally {
    tester.getLock().unlock();
   }
  }
 }
}

运行结果如下：
Thread[Thread-0,5,main] started.
Thread[Thread-1,5,main] started.
Thread[Thread-2,5,main] started.
Thread[Thread-3,5,main] condition signal.
Thread[Thread-0,5,main] get condition.
Thread[Thread-3,5,main] condition signal.
Thread[Thread-1,5,main] get condition.
Thread[Thread-3,5,main] condition signal.
Thread[Thread-2,5,main] get condition.
Thread[Thread-3,5,main] condition signal.
Thread[Thread-0,5,main] get condition.