CompletableFuture + LinkedBlockingDeque 实现生产者消费者案例

设计要求：

1. 设计一个生产者生产，消费者消费场景；

2. 使用线程池 CompletableFuture + 队列LinkedBlockingDeque 实现；

3. 生产者生产的数据存储到长度为5的 LinkedBlockingDeque 队列，消费者消费从 LinkedBlockingDeque 队列中取数据；

4. 生产者和消费者均是多线程且不知道谁快谁慢，互不干扰；

5. 消费者根据生产者情况进行结束

以下为模板案例代码，可以封装成工具类使用：

package com.xx.product.manage.service;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;

public class ProducerConsumerExample {
    public static void main(String[] args) {

        LinkedBlockingDeque<Integer>  queue = new LinkedBlockingDeque<>(5);
        Executor executor = Executors.newFixedThreadPool(2);

        AtomicBoolean producerFinished = new AtomicBoolean(false);

        CompletableFuture <Void> producerFuture = CompletableFuture.runAsync(() ->  {
            try {
                for (int i = 1; i <= 10; i++) {
                    // 生产数据
                    System.out.println("Producing: " + i);
//                    Thread.sleep(3000); //验证 消费者速度 > 生产者速度
                    queue.put(i);

                    // 如果队列已满，等待消费者消费数据
                    if (queue.size() == 5) {
                        System.out.println("Queue is full. Waiting for consumer...");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 生产者结束
            producerFinished.set(true);
            System.out.println("Producer finished.");
        }, executor);

        CompletableFuture <Void>  consumerFuture = CompletableFuture.runAsync(() ->  {
            try {
                while (true) {
                    // 如果队列为空且生产者已结束，则消费者退出循环
                    if (queue.isEmpty() && producerFinished.get()) {
                        break;
                    }

                    // 消费数据
//                    Thread.sleep(2000); //验证生产者速度 > 消费者速度
                    Integer item = queue.take();
                    if (item != null) {
                        System.out.println("Consuming: " + item);
                    } else {
                        // 如果队列为空，等待生产者生产数据
                        System.out.println("Queue is empty. Waiting for producer...");
                        Thread.sleep(1000);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Consumer finished.");
        }, executor);

        // 等待生产者和消费者都完成
        CompletableFuture.allOf(producerFuture, consumerFuture).join();
        System.out.println("All tasks finished.");

        // 关闭线程池
        ((ExecutorService) executor).shutdown();
    }
}

 知识点：