基于阻塞队列实现的简单生产者-消费者模式

生产者：生成数据放入到队列中，供消费者消费；

消费者：从队列中获取数据，进行消费。

下面是一个简单的生产者-消费者模式代码实例：

生产者线程每隔3秒生产一个随机数并放入到阻塞队列中，消费者线程不断得去队列中获取元素进行消费。

1、生产者代码

/**
 * @Description: 生产者
 * @author: Alan
 * @Date: 2019/1/1 21:46
 */
public class Producer implements Runnable {

    private final BlockingQueue queue;

    public Producer(BlockingQueue q) {
        this.queue = q;
    }

    @Override
    public void run() {
        try {
            while (true) {
                //将生产的对象放入阻塞队列中，供消费者消费
                queue.put(produce());
                Thread.sleep(3000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 生产方法
     *
     * @return
     */
    public Object produce() {
        double num = Math.random();
        System.out.println(Thread.currentThread().getName() + "生产了随机数 " + num);
        return num;
    }
}

2、消费者代码

/**
 * @Description: 消费者
 * @author: Alan
 * @Date: 2019/1/1 21:46
 */
public class Consumer implements Runnable {

    private final BlockingQueue queue;

    public Consumer(BlockingQueue q) {
        this.queue = q;
    }

    @Override
    public void run() {
        try {
            while (true) {
                //从阻塞队列中取出元素并进行消费
                consume(queue.take());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 消费方法
     *
     * @param o
     */
    public void consume(Object o) {
        System.out.println(Thread.currentThread().getName() + "消费者消费了" + o.toString());
    }
}

3、main方法

/**
 * @Description: 使用BlockingQueue实现的简单生产者-消费者模式
 * @author: Alan
 * @Date: 2019/1/1 21:46
 */
public class Main {
    public static void main(String[] args) {
        //阻塞队列
        BlockingQueue queue = new LinkedBlockingQueue();
        //实例化生产者
        Producer producer = new Producer(queue);
        //实例化消费者1
        Consumer consumer1 = new Consumer(queue);
        //实例化消费者2
        Consumer consumer2 = new Consumer(queue);
        //启动生产者线程
        new Thread(producer).start();
        //启动消费者1线程
        new Thread(consumer1).start();
        //启动消费者2线程
        new Thread(consumer2).start();

    }
}

运行结果

Thread-0生产了随机数 0.4148294452924416
Thread-1消费者消费了0.4148294452924416
Thread-0生产了随机数 0.2548693317829043
Thread-2消费者消费了0.2548693317829043
Thread-0生产了随机数 0.7716023641452534
Thread-1消费者消费了0.7716023641452534
Thread-0生产了随机数 0.918439707362971
Thread-2消费者消费了0.918439707362971
Thread-0生产了随机数 0.8355631426120482
Thread-1消费者消费了0.8355631426120482