创建两个CompletableFuture 第1个CompletableFuture向LinkedBlockingQueue 1插数据 第2个CompletableFuture从LinkedBlockingQueue 1中取数据加工插入LinkedBlockingQueue 2 再有有个while 遍历 LinkedBlockingQueue 2把数据放入ThreadPoolExecutor线程池中处理 这三个处理都同时处理 加快效率

好的，我明白你的需求。下面是使用 CompletableFuture 和 LinkedBlockingQueue 实现你描述的操作流程的示例代码：

import java.util.concurrent.*;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建 LinkedBlockingQueue 1
        LinkedBlockingQueue<Integer> queue1 = new LinkedBlockingQueue<>();

        // 创建 LinkedBlockingQueue 2
        LinkedBlockingQueue<Integer> queue2 = new LinkedBlockingQueue<>();

        // 创建 ThreadPoolExecutor 线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                10, // 核心线程数
                10, // 最大线程数
                1, TimeUnit.SECONDS, // 线程空闲超时时间
                new ArrayBlockingQueue<>(100) // 任务队列
        );

        // 创建第一个 CompletableFuture，向 queue1 插入数据
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    queue1.put(i); // 插入数据到 queue1
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 创建第二个 CompletableFuture，从 queue1 取数据加工后插入 queue2
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            try {
                while (true) {
                    int value = queue1.take(); // 从 queue1 取数据
                    // 加工数据
                    int processedValue = value * 2;
                    queue2.put(processedValue); // 插入加工后的数据到 queue2
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 创建第三个 CompletableFuture，从 queue2 取数据并放入线程池中处理
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(() -> {
            try {
                while (true) {
                    int value = queue2.take(); // 从 queue2 取数据
                    // 在线程池中处理数据
                    executor.execute(() -> processValue(value));
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 等待三个 CompletableFuture 全部完成
        CompletableFuture.allOf(future1, future2, future3).join();

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

    private static void processValue(int value) {
        // 处理数据的逻辑
        System.out.println("Processing value: " + value);
        // ...
    }
}

上述代码中，我们创建了三个 `CompletableFuture` 对象，分别用于向 `queue1` 插入数据、从 `queue1` 取数据加工后插入 `queue2`，以及从 `queue2` 取数据并放入线程池中处理。最后，我们使用 `CompletableFuture.allOf()` 等待三个 `CompletableFuture` 完成，并关闭线程池。

注意：上述示例代码只是一个简单的示例，如果你的实际需求更加复杂，你可能需要根据具体情况进行相应的调整和扩展。