并发库应用之六 & 有条件阻塞Condition应用

Condition的功能类似在传统线程技术中的 Object.wait() 和 Object.natify() 的功能，传统线程技术实现的互斥只能一个线程单独干，不能说这个线程干完了通知另一个线程来干，Condition就是解决这个问题的，实现线程间的通信。比如CPU让小弟做事，小弟说我先歇着先让大哥做并通知大哥，大哥就开始做事。

　　接口：public interface Condition

　　Condition 将 Object 监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

　　Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其 newCondition() 方法。

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

　　一个锁内部可以有多个Condition，即有多路等待和通知，可以参看jdk1.5提供的 Lock 与 Condition 实现的可阻塞队列的应用案例，从中除了要体味算法，还要体味面向对象的封装。

Condition使用案例之一：实现两个线程交替执行

 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 ConditionTest {

     public static void main(String[] args) {
         ExecutorService service = Executors.newSingleThreadExecutor();
         final Business2 business = new Business2();
         service.execute(new Runnable() {//提交5个business.sub方法任务到单个线程池中
             public void run() {
                 for (int i = 0; i < 5; i++) {
                     business.sub();
                 }
             }

         });

         for (int i = 0; i < 5; i++) {//执行5次business.main方法
             business.main();
         }
     }

 }

 class Business2 {
     Lock lock = new ReentrantLock();
     Condition condition = lock.newCondition();//得到当前锁阻塞条件
     boolean isSub = true; //默认一开始限制性sub任务

     public void sub() {
         lock.lock();
         if (!isSub) {//不是sub执行条件，则进入进行阻塞处理
             try {
                 condition.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         try {
             for (int i = 0; i < 5; i++) {
                 System.out.println(Thread.currentThread().getName() + " : " + i);
             }
             isSub = false;
             condition.signal();
         } finally {
             lock.unlock();
         }

     }

     public void main() {
         lock.lock();
         if (isSub) { //是sub执行任务，则进入阻塞main任务
             try {
                 condition.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         try {
             for (int i = 0; i < 5; i++) {
                 System.out.println(Thread.currentThread().getName() + " : " + i);
             }
             isSub = true;
             condition.signal();
         } finally {
             lock.unlock();
         }
     }
 }

运行结果如下：

　　

Condition使用案例之二：实现三个线程交替执行

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

 public class SignalTest2 {
     public static void main(String[] args) {
         new SignalTest2().init();
     }

     private void init() {
         final Business b = new Business();
         new Thread() {
             public void run() {
                 for (int i = 0; i < 5; i++)
                     b.sub1();
             }
         }.start();

         new Thread() {
             public void run() {
                 for (int i = 0; i < 5; i++)
                     b.sub2();
             }
         }.start();

         new Thread() {
             public void run() {
                 for (int i = 0; i < 5; i++)
                     b.sub3();
             }
         }.start();
     }

     private class Business {
         int status = 1;//开始默认执行第一个方法
         Lock lock = new ReentrantLock();
         Condition cond1 = lock.newCondition();
         Condition cond2 = lock.newCondition();
         Condition cond3 = lock.newCondition();

         public void sub1() {
             lock.lock();
             while (status != 1) {
                 try {
                     cond1.await();
                 } catch (Exception e) {
                 }
             }
             for (int i = 1; i <= 5; i++) {
                 try {
                     Thread.sleep(200);
                 } catch (Exception e) {}
                 System.out.println("[sub1]" + Thread.currentThread().getName() + ":" + i);
             }
             status = 2;//1执行完指定2开始执行
             cond2.signal();
             lock.unlock();
         }

         public void sub2() {
             lock.lock();
             while (status != 2) {
                 try {
                     cond2.await();
                 } catch (Exception e) {
                 }
             }
             for (int i = 1; i <= 5; i++) {
                 try {
                     Thread.sleep(200);
                 } catch (Exception e) {}
                 System.out.println("[sub2]" + Thread.currentThread().getName() + ":" + i);
             }
             status = 3;//2执行完指定3开始执行
             cond3.signal();
             lock.unlock();
         }

         public void sub3() {
             lock.lock();
             while (status != 3) {
                 try {
                     cond3.await();
                 } catch (Exception e) {
                 }
             }
             for (int i = 1; i <= 5; i++) {
                 try {
                     Thread.sleep(200);
                 } catch (Exception e) {
                 }
                 System.out.println("[sub3]" + Thread.currentThread().getName() + ":" + i);
             }
             status = 1;//3执行完指定1开始执行
             cond1.signal();
             lock.unlock();
         }
     }
 }

运行结果如下：

　　

提示：欢迎继续参看我相关的下一篇博客：并发库应用之七 & 信号灯Semaphore应用