实现模式的一种方法是：
构造一个多线程执行器来处理解码请求
拥有消费者队列；每次提交要解码的项时，还将相应的future对象添加到使用者队列中
让使用者线程等待从队列中取出项目[因此按照发布的顺序使用它们]，调用相应的get（）方法[等待项目被解码]
所以“消费者”看起来是这样的：

BlockingQueue<Future<Item>> consumerQueue = new LinkedBlockingDeque<>();
Thread consumerThread = new Thread(() -> {
        try {
            while (true) {
                Future<Item> item = consumerQueue.take();
                try {
                    // Get the next decoded item that's ready
                    Item decodedItem = item.get();
                    // 'Consume' the item
                    ...
                } catch (ExecutionException ex) {
                }
            }
        } catch (InterruptedException irr) {

        }
    });
    consumerThread.start()

同时，“producer”端及其多线程“decoder”将如下所示：

ExecutorService decoder = Executors.newFixedThreadPool(4);
while (!producer.hasNext()) {
        Item item = producer.next()

        // Submit the decode job for asynchronous processing
        Future<Item> p = decoder.submit(() -> {
            item.decode();
        }, item);

        // Also queue this decode job for future consumption once complete
        consumerQueue.add(p);
    }

作为一个单独的问题，我想知道你是否真的会在实践中看到很多好处，因为坚持以同样的顺序消费，你就内在地在这个过程中引入了一个连续的条件。但从技术上讲，这是一种方法，你可以实现你所追求的。
p、 如果您不需要一个单独的使用者线程，那么同一个“生产者”线程可以轮询队列中已完成的项目并按行执行。

尝试

while(producer.next()) {
   CompletableFuture.supplyAsync(()-> gson.deserialize(producer.item()))
    .thenRunAsync(item->processItem(item));
}