CompletableFuture.supplyAsync() 没有 Lambda

Question

我正在努力使用Supplier<U>等的功能样式并创建可测试的代码。

所以我有一个InputStream ，它被分成异步处理的块，我想知道它们什么时候完成。 为了编写可测试的代码，我将处理逻辑外包给它自己的Runnable ：

public class StreamProcessor {
    
    public CompletableFuture<Void> process(InputStream in) {
        List<CompletableFuture> futures = new ArrayList<>();
        while (true) {
            try (SizeLimitInputStream chunkStream = new SizeLimitInputStream(in, 100)) {
                byte[] data = IOUtils.toByteArray(chunkStream);
                CompletableFuture<Void> f = CompletableFuture.runAsync(createTask(data));
                futures.add(f);
                
            } catch (EOFException ex) {
                // end of stream reached
                break;
            } catch (IOException ex) {
                return CompletableFuture.failedFuture(ex);
            }
        }
        return CompletableFuture.allOf(futures.toArray(CompletableFuture<?>[]::new));
    }
    
    ChunkTask createTask(byte[] data) {
        return new ChunkTask(data);
    }
    
    public class ChunkTask implements Runnable {
        final byte[] data;

        ChunkTask(byte[] data) {
            this.data = data;
        }

        @Override
        public void run() {
            try {
                // do something
            } catch (Exception ex) {
                // checked exceptions must be wrapped
                throw new RuntimeException(ex);
            }
        }
        
    }
}

这很好用，但会带来两个问题：

1. 处理代码不能返回任何东西； 毕竟这是一个Runnable 。
2. 在ChunkTask.run()中捕获的任何已检查异常都必须包装到RuntimeException中。 解包失败的组合CompletableFuture会返回RuntimeException ，需要再次解包才能达到原始原因 - 与IOException不同。

因此，我正在寻找一种使用CompletableFuture.supplyAsync()执行此操作的方法，但我无法弄清楚如何在没有 lambdas（不好测试）或从处理逻辑返回CompletableFuture.failedFuture()的情况下执行此操作。

Answer 1

我可以想到两种方法：

1. 使用supplyAsync ：

使用CompletableFuture.supplyAsync时，您需要一个供应商而不是可运行的：

    public static class ChunkTask implements Supplier<Object> {
        final byte[] data;

        ChunkTask(byte[] data) {
            this.data = data;
        }

        @Override
        public Object get() {
            Object result = ...;
            // Do something or throw an exception
            return result;
        }
    }

接着：

CompletableFuture
    .supplyAsync( new ChunkTask( data ) )
    .whenComplete( (result, throwable) -> ... );

如果Supplier.get()中发生异常，它将被传播，您可以在CompletableFuture.whenComplete 、 CompletableFuture.handle或CompletableFuture.exceptionally中看到它。

2. 将CompletableFuture传递给线程

您可以将CompletableFuture传递给ChunkTask ：

    public class ChunkTask implements Runnable {
        final byte[] data;
        private final CompletableFuture<Object> future;

        ChunkTask(byte[] data, CompletableFuture<Object> future) {
            this.data = data;
            this.future = future;
        }

        @Override
        public void run() {
            try {
                Object result = null;
                // do something
                future.complete( result );
            } catch (Throwable ex) {
                future.completeExceptionally( ex );
            }
        }
    }

那么逻辑就变成了：

while (true) {
    CompletableFuture<Object> f = new CompletableFuture<>();
    try (SizeLimitInputStream chunkStream = new SizeLimitInputStream(in, 100)) {
        byte[] data = IOUtils.toByteArray(chunkStream);
        startThread(new ChunkTask(data, f));
        futures.add(f);
     } catch (EOFException ex) {
         // end of stream reached
         break;
     } catch (IOException ex) {
         f.completeExceptionally( ex );
         return f;
     }
}

可能，第 2 项可以让您更灵活地管理异常。