生产者-消费者模型的3种Java实现：synchronized，signal/notifyAll及BlockingQueue

我的技术博客经常被流氓网站恶意爬取转载。请移步原文：http://www.cnblogs.com/hamhog/p/3555111.html，享受整齐的排版、有效的链接、正确的代码缩进、更好的阅读体验。

【实现1：synchronized】

含测试函数main。

public class ProductManagerUsingSync {

    static final int MAX_AMOUNT = 1000;
    int currentAmount;

    /**
     * @param args
     */
    public static void main(String[] args) {
        ProductManagerUsingSync manager = new ProductManagerUsingSync(); 

        for (int i = 0; i < 5; i++){
            int consume = (int) Math.round(Math.random()*50) + 10;
            Thread consumerThread = new Thread(new ConsumerWithSync(consume, manager));
            consumerThread.start();
        }

        for (int i = 0; i < 10; i++){
            int produce = (int) Math.round(Math.random()*50) + 10;
            Thread producerThread = new Thread(new ProducerWithSync(produce, manager));
            producerThread.start();
        }
    }

    public ProductManagerUsingSync() {
        currentAmount = 0;
    }

    /**
     * Add product. If can't, return.
     * @param addAmount
     * @return if succeeded.
     */
    public boolean addProduct(int addAmount){
        if (currentAmount + addAmount > MAX_AMOUNT)
            return false;

        currentAmount += addAmount;
        System.out.println("produced: " + addAmount + " current: " + currentAmount);
        return true;
    }

    /**
     * Take product. If can't, return.
     * @param takeAmount The amount of product to take.
     * @return if succeeded.
     */
    public boolean takeProduct(int takeAmount){
        if (takeAmount > currentAmount)
            return false;

        currentAmount -= takeAmount;
        System.out.println("consumed: " + takeAmount + " current: " + currentAmount);
        return true;
    }

}

class ProducerWithSync implements Runnable {
    private int amount;
    private ProductManagerUsingSync manager; 

    ProducerWithSync(int amount, ProductManagerUsingSync manager) {
        this.amount = amount;
        this.manager = manager;
    } 

    @Override
    public void run() {
        while (true) {
            synchronized (manager) {
                if (manager.addProduct(amount))
                    return;
            }
        }
    }
} 

class ConsumerWithSync implements Runnable {
    private int amount;
    private ProductManagerUsingSync manager;

    ConsumerWithSync(int amount, ProductManagerUsingSync manager) {
        this.amount = amount;
        this.manager = manager;
    } 

    @Override
    public void run() {
        while (true) {
            synchronized (manager) {
                if (manager.takeProduct(amount))
                    return;
            }
        }
    }
}

解释：Consumer类和Producer类在run方法中进行产品的生产和消费。重点在于：1. 在尝试生产、消费前会获取manager上的锁。由于所有的生产者、消费者中的manager都是同一个实例，因此消费、生产过程是保证线程安全（单线程串行）的。2. 在生产、消费失败的情况下，会进入死循环，反复再次尝试，直到成功为止。

这种实现方法下，暂时不能生产、消费时需要一直死循环，太占资源了；如果在每次循环之间sleep，则不一定能及时生产、消费。

【实现2：signal/notifyAll】

含测试函数main。

public class ProductManagerUsingSignal {

    static final int MAX_AMOUNT = 1000;
    int currentAmount;

    /**
     * @param args useless
     */
    public static void main(String[] args) {
        ProductManagerUsingSignal manager = new ProductManagerUsingSignal(); 

        for (int i = 0; i < 5; i++){
            int consume = (int) Math.round(Math.random()*50);
            Thread consumerThread = new Thread(new Consumer(consume, manager));
            consumerThread.start();
        }

        for (int i = 0; i < 10; i++){
            int produce = (int) Math.round(Math.random()*50);
            Thread producerThread = new Thread(new Producer(produce, manager));
            producerThread.start();
        }
    }

    public ProductManagerUsingSignal(){
        currentAmount = 0;
    }

    /**
     * Add product. If can't, wait. NotifyAll when finished.
     * @param addAmount The amount of product to add.
     */
    public synchronized void addProduct(int addAmount){
        while (currentAmount + addAmount > MAX_AMOUNT) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        currentAmount += addAmount;
        System.out.println("produced: " + addAmount + " current: " + currentAmount);
        notifyAll();
    }

    /**
     * Take product. If can't, wait. NotifyAll when finished.
     * @param takeAmount The amount of product to take.
     */
    public synchronized void takeProduct(int takeAmount){
        while (takeAmount > currentAmount) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        currentAmount -= takeAmount;
        System.out.println("consumed: " + takeAmount + " current: " + currentAmount);
        notifyAll();
    }

}

class Producer implements Runnable {
    private int amount;
    private ProductManagerUsingSignal manager; 

    Producer(int amount, ProductManagerUsingSignal manager) {
        this.amount = amount;
        this.manager = manager;
    } 

    @Override
    public void run() {
        manager.addProduct(amount);
    }
} 

class Consumer implements Runnable {
    private int amount;
    private ProductManagerUsingSignal manager;

    Consumer(int amount, ProductManagerUsingSignal manager) {
        this.amount = amount;
        this.manager = manager;
    } 

    @Override
    public void run() {
        manager.takeProduct(amount);
    }
}

解释：这种实现同样用synchronized保证线程安全；它的重点在于，当生产、消费失败时，会进入wait状态，让位给其他线程；而完成一次成功的生产或消费后，会调用notifyAll方法，唤醒之前等待状态的进程。这种实现在效率上要好于第一种。

【实现3：BlockingQueue】

含测试函数main。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ProductManagerUsingBlockingQueue {

    BlockingQueue<Integer> sharedQueue;

/**
     * @param args
     */
    public static void main(String[] args) {
        sharedQueue = new LinkedBlockingQueue<Integer>();

        for (int i = 0; i < 10; i++){
            Thread consumerThread = new Thread(new ConsumerWithBlockingQueue(sharedQueue));
            consumerThread.start();
        }

        for (int i = 0; i < 10; i++){
            Thread producerThread = new Thread(new ProducerWithBlockingQueue(i, sharedQueue));
            producerThread.start();
        }
    }

}

class ProducerWithBlockingQueue implements Runnable {

    private int amount;
    private final BlockingQueue<Integer> sharedQueue;

    public ProducerWithBlockingQueue (int amount, BlockingQueue<Integer> sharedQueue) {
        this.amount = amount;
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {

        try {
            sharedQueue.put(amount);
            System.out.println("produced: " + amount);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class ConsumerWithBlockingQueue implements Runnable{

    private final BlockingQueue<Integer> sharedQueue;

    public ConsumerWithBlockingQueue (BlockingQueue<Integer> sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        try {
            System.out.println("consumed: " + sharedQueue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

解释：这种方法借助数据结构BlockingQueue（初始化好像应该放在构造函数里，暂时来不及改了），底层原理与signal/notifyAll类似，但代码实现就简洁了许多。

【总结】

在需要实现生产者-消费者模式的场景下，我们可以优先考虑用BlockingQueue来实现。