条件阻塞Condition的应用

Condition的功能类似在传统线程技术中的Object.wait和Object.notity的功能。

 

例子：生产者与消费者

 

import java.util.Random;
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;
 
/**
 * 有时候线程取得lock后需要在一定条件下才能做某些工作，比如说经典的Producer和Consumer问题。 在Java
 * 5.0以前，这种功能是由Object类的wait(), notify()和notifyAll()等方法实现的，
 * 在5.0里面，这些功能集中到了Condition这个接口来实现。
 */
public class ConditionTest {
 
        /**
        * 篮子程序。Consumer必须在篮子里有苹果的时候才能吃苹果，否则它必须暂时放弃对篮子的锁定，
        * 等到Producer往篮子里放了苹果后再去拿来吃。而Producer必须等到篮子空了才能往里放苹果，
        * 否则它也需要暂时解锁等Consumer把苹果吃了才能往篮子里放苹果。
        */
        public static class Basket {
               // 锁
              Lock lock = new ReentrantLock();
               // 根据锁产生Condition对象
              Condition produced = lock .newCondition();
              Condition consumed = lock .newCondition();
               // 篮子中的苹果数
               int num = 0;
               // 篮子中的最多放的苹果数
               int count = 5;
 
               /**
               * 生产苹果，往篮子里放
               *
               * @throws InterruptedException
               */
               public void produce() throws InterruptedException {
                      // 获得锁
                      lock.lock();
                     System. out.println("Producer get a lock..." );
                      try {
                            // 判断是否满足生产条件
                            while (num == count) {
                                   // 如果有苹果，则不生产，放弃锁，进入睡眠
                                   // 等待消费者消费
                                  System. out.println("Producer sleep..." );
                                   consumed.await();
                                  System. out.println("Producer awaked..." );
                           }
                            /* 生产苹果 */
                           Thread. sleep(new Random().nextInt(50));
                           System. out.println("Producer produced an Apple." );
                            num++;
                           System. out.println("Producer 篮子里有" + num + "个苹果" );
                            // 通知等待produced Condition的线程
                            produced.signal();
                     } finally {
                            lock.unlock();
                     }
              }
 
               /**
               * 消费苹果，从篮子中取
               *
               * @throws InterruptedException
               */
               public void consume() throws InterruptedException {
                      // 获得锁
                      lock.lock();
                     System. out.println("Consumer get a lock..." );
                      try {
                            // 判断是否满足消费条件
                            while (num == 0) {
                                   // 如果没有苹果，无法消费，则放弃锁，进入睡眠
                                   // 等待生产者生产苹果
                                  System. out.println("Consumer sleep..." );
                                   produced.await();
                                  System. out.println("Consumer awaked..." );
                           }
                            /* 吃苹果 */
                           Thread. sleep(new Random().nextInt(500));
                           System. out.println("Consumer consumed an Apple." );
                            num--;
                           System. out.println("Consumer 篮子里剩" + num + "个苹果" );
                            // 发信号唤醒某个等待consumed Condition的线程
                            consumed.signal();
                     } finally {
                            lock.unlock();
                     }
              }
       }
 
        /**
        * 测试Basket程序
        */
        public static void testBasket() throws Exception {
               final Basket basket = new Basket();
               // 定义一个producer
              Runnable producer = new Runnable() {
                      public void run() {
                            try {
                                  basket.produce();
                           } catch (InterruptedException ex) {
                                  ex.printStackTrace();
                           }
                     }
              };
 
               // 定义一个consumer
              Runnable consumer = new Runnable() {
                      public void run() {
                            try {
                                  basket.consume();
                           } catch (InterruptedException ex) {
                                  ex.printStackTrace();
                           }
                     }
              };
 
               // 各产生10个consumer和producer
              ExecutorService service = Executors. newCachedThreadPool();
               for (int i = 0; i < 10; i++) {
                     service.execute(producer);
              }
               for (int i = 0; i < 10; i++) {
                     service.execute(consumer);
              }
              service.shutdown();
       }
 
        public static void main(String[] args) throws Exception {
              ConditionTest. testBasket();
       }
}