Java5并发库之条件阻塞Condition的应用

锁只能实现互斥，不能实现线程之间的通信(可以参看一个线程间通信的例子http://020618.blog.51cto.com/6098149/1182807)，而Condition可以解决这个问题，即使CPU分给了当前的线程，但是当前的线程可以让出CPU，让其它的相称执行，当前线程暂停，当其它的线程执行完后，在通知当前的线程，这样就实现了线程之间的通信。

Java5并发库中的Condition的功能类似在传统线程技术中的Object.wait()和Object.notify()的功能，在等待Condition时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这实际带来的影响很小，因为Condition应该总是在一个循环中等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序员总是这些虚假唤醒可能发生，因此，总是在下一个循环中等待。

虽然Condition的功能类似在传统线程技术中的Object.wait()和Object.notify()的功能，但是Condition可以实现synchronizd实现不了的功能。

下面看一个Condition的代码例子：实现3个线程时间的交替执行，使main线程唤sub2线程，sub2线程唤醒sub3线程，sub3线程唤醒main线程，如此循环50次。代码如下：

• 1-1 一个Condition的例子

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

public class ThreeConditionCommunication {
    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        for(int i=1;i<=50;i++){
                            business.sub2(i);
                        }
                    }
                }
        ).start();

        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        for(int i=1;i<=50;i++){
                            business.sub3(i);
                        }
                    }
                }
        ).start();

        for(int i=1;i<=50;i++){
            business.main(i);
        }

    }
/*
 main线程唤sub2线程，sub2线程唤醒sub3线程，sub3线程唤醒main线程，需要三个条件
 */
    static class Business {
            Lock lock = new ReentrantLock();
            Condition condition1 = lock.newCondition();
            Condition condition2 = lock.newCondition();
            Condition condition3 = lock.newCondition();
          private int shouldSub = 1;//刚开始main线程先执行
          public  void sub2(int i){//子线程2
              lock.lock();
              try{
                  while(shouldSub != 2){
                      try {
                        condition2.await();//sub2线程在等待主线程
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                  }
                    for(int j=1;j<=10;j++){
                        System.out.println("sub2 thread sequence of " + j + ",loop of " + i);
                    }
                  shouldSub = 3;//执行完之后通知sub3线程
                  condition3.signal();//通知sub3线程开始执行
              }finally{
                  lock.unlock();
              }
          }

          public  void sub3(int i){//子线程3
              lock.lock();
              try{
                  while(shouldSub != 3){//不该sub3线程执行
                      try {
                        condition3.await();//sub3线程执行
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                  }
                    for(int j=1;j<=20;j++){
                        System.out.println("sub3 thread sequence of " + j + ",loop of " + i);
                    }
                  shouldSub = 1;//执行完之后通知main线程
                  condition1.signal();//main线程开始执行
              }finally{
                  lock.unlock();
              }
          }

          public  void main(int i){//主线程
              lock.lock();
              try{
                 while(shouldSub != 1){//不该main线程执行
                        try {
                            condition1.await();//main线程等待
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    for(int j=1;j<=100;j++){
                        System.out.println("main thread sequence of " + j + ",loop of " + i);
                    }
                    shouldSub = 2;//main线程通知sub2线程执行
                    condition2.signal();//sub2线程按开始执行
          }finally{
              lock.unlock();
          }
      }
    }
}

程序运行的结果：

上面的代码是在 一个线程通信的例子(http://020618.blog.51cto.com/6098149/1182807)的基础上进行改写的，感兴趣的朋友可以看一下。