Java多线程之Condition接口的实现

【Condition】

Condition可以用来实现wait、notify、notifyAll方法的线程间同步通信。但其有增强的地方。我们先看一下wait等方法的使用情况：我们先得到一个对象的监视器，进入同步代码块，发现有些条件限制，我们的线程就要wait在这个对象监视器上，如果我们有100个线程，这100条线程有可能会因为不同的条件限制而要wait，但结果是他们都wait在同一个对象监视器上。一旦有另一个线程处理完了某种条件限制，这种限制的解除会让这100条线程中的5条可以继续执行，但这个线程无法通过notify去精确通知这5条线程，他只能调用notifyAll，去通知所有线程，然后其中95条再重新获取到对象监视器后发现不得不继续wait！！这是wait等方法低效的地方，Condition就对这种情况进行了很好的改进！在使用同一个锁进行互斥控制的线程，可以在不同的Condition对象上进行等待和被唤醒！这就是"多路Condition"的概念！

package com.uppower.thread;

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();

        // 篮子中的苹果数，最多为1
        int num = 0;

        /**
         * 生产苹果，往篮子里放
         * @throws InterruptedException
         */
        public void produce() throws InterruptedException {
            // 获得锁
            lock.lock();
            System.out.println("Producer get a lock...");
            try {
                // 判断是否满足生产条件
                while (num == 1) {
                    // 如果有苹果，则不生产，放弃锁，进入睡眠
                    // 等待消费者消费
                    System.out.println("Producer sleep...");
                    consumed.await();
                    System.out.println("Producer awaked...");
                }
                /* 生产苹果 */
                Thread.sleep(500);
                System.out.println("Producer produced an Apple.");
                num = 1;
                // 通知等待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(500);
                System.out.println("Consumer consumed an Apple.");
                num = 0;
                // 发信号唤醒某个等待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();
                }
            }
        };

        // 各产生3个consumer和producer
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            service.submit(producer);
        }
        for (int i = 0; i < 3; i++) {
            service.submit(consumer);
        }
        service.shutdown();
    }

    public static void main(String[] args) throws Exception {
        ConditionTest.testBasket();
    }
}

运行输出结果：

Producer get a lock...
Producer produced an Apple.
Producer get a lock...
Producer sleep...
Consumer get a lock...
Consumer consumed an Apple.
Producer get a lock...
Producer produced an Apple.
Consumer get a lock...
Consumer consumed an Apple.
Consumer get a lock...
Consumer sleep...
Producer awaked...
Producer produced an Apple.
Consumer awaked...
Consumer consumed an Apple.