CompletableFuture把处理完的数据放入LinkedBlockingQueue 同时起个线程池去处理LinkedBlockingQueue 这两个都是同时执行

你可以使用`CompletableFuture`和`LinkedBlockingQueue`来实现并行处理数据和使用线程池处理`LinkedBlockingQueue`中的数据。下面是一个简单的示例代码：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class CompletableFutureExample {
    public static void main(String[] args) {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        
        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // 使用CompletableFuture处理数据并将结果放入队列
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            for (int i = 0; i < 10; i++) {
                int result = processData(i); // 处理数据的方法
                try {
                    queue.put(result);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, executor);
        
        // 使用线程池处理队列中的数据
        executor.execute(() -> {
            while (true) {
                try {
                    int data = queue.take();
                    processQueueData(data); // 处理队列中的数据的方法
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        // 等待处理完成
        completableFuture.join();
    }
    
    private static int processData(int data) {
        // 处理数据的逻辑
        return data * 2;
    }
    
    private static void processQueueData(int data) {
        // 处理队列中的数据的逻辑
        System.out.println("Processed data: " + data);
    }
}

在上面的示例中，`CompletableFuture`会并行处理数据，并将处理完的结果放入`LinkedBlockingQueue`中。然后，使用线程池从队列中取出数据并进行处理。注意，这里使用了固定大小为10的线程池来处理队列中的数据。你可以根据实际需求来调整线程池的大小。