标签: completable-future

我没有看到使用异步结果处理异常的明显方法.例如,如果我想重试异步操作.我希望这样的东西,但handleAsync不会做你认为它做的事情 - 它在异步运行另一个线程上的回调.在这里返回CompletionStage是不正确的.当天的危害问题:thenApply就是thenCompose因为exceptionally是为了什么？

CompletionStage<String> cf = askPong("cause error").handleAsync((x, t) -> {
    if (t != null) {
        return askPong("Ping");
    } else {
        return x;
    }
});

askPong问演员的地方:

public CompletionStage<String> askPong(String message){
    Future sFuture = ask(actorRef, message, 1000);
    final CompletionStage<String> cs = toJava(sFuture);
    return cs;
} 

使用AsyncHttpClientwith Netty提供程序将阻止主程序在执行异步请求时终止.例如,下面的程序后终止println,或没有,这取决于供应商是否JDKAsyncHttpProvider还是NettyAsyncHttpProvider:

public class Program {
    public static CompletableFuture<Response> getDataAsync(String uri) {
        final AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
        final CompletableFuture<Response> promise = new CompletableFuture<>();
        asyncHttpClient
            .prepareGet(uri)
            .execute(new AsyncCompletionHandler<Response>(){
                @Override
                public Response onCompleted(Response resp) throws Exception {
                    promise.complete(resp);
                    asyncHttpClient.close(); // ??? Is this correct ????
                    return resp;
                }
            });
        return promise;
    }

    public static void main(String [] args) throws Exception {
        final String uri = "…";
        System.out.println(getDataAsync(uri).get());
    }
}

关于AsynHttpClient文档说明: …

例如我有这样的方法：

public CompletableFuture<Page> getPage(int i) {
    ...
}
public CompletableFuture<Document> getDocument(int i) {
    ...
}
public CompletableFuture<Void> parseLinks(Document doc) {
    ...
}

而我的流程：

List<CompletableFuture> list = IntStream
    .range(0, 10)
    .mapToObj(i -> getPage(i))

    // I want method like this:
    .thenApplyAndSplit(CompletableFuture<Page> page -> {
        List<CompletableFuture<Document>> docs = page.getDocsId()
            .stream()
            .map(i -> getDocument(i))
            .collect(Collectors.toList());
        return docs;
    })
    .map(CompletableFuture<Document> future -> {
        return future.thenApply(Document doc -> parseLink(doc);
    })
    .collect(Collectors.toList());

它应该类似于flatMap()for CompletableFuture，所以我想实现这个流程：

List<Integer> -> Stream<CompletableFuture<Page>>
              -> Stream<CompletableFuture<Document>>
              -> parse each

更新

Stream<CompletableFuture<Page>> …

我有一种情况，我必须轮询远程服务器以检查任务是否已完成。完成后，我将进行另一个调用以检索结果。

我最初认为我应该使用SingleThreadScheduledExecutorwith scheduleWithFixedDelay进行轮询：

ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
ScheduledFuture future = executor.scheduleWithFixedDelay(() -> poll(jobId), 0, 10, TimeUnit.SECONDS);

public void poll(String jobId) {
   boolean jobDone = remoteServer.isJobDone(jobId);
   if (jobDone) {
       retrieveJobResult(jobId);
   }
}

但是，因为我只能提供Runnable给scheduleWithFixedDelay不能返回任何东西，我不明白时，future就完成了，如果有的话。打电话future.get()甚至意味着什么？我在等什么结果？

第一次检测到远程任务完成时，我想执行一个不同的远程调用并将其结果设置为的值future。我认为我可以为此使用CompletableFuture，以便将其转发给我的poll方法，然后将其转发给retrieveTask最终将完成它的方法：

CompletableFuture<Object> result = new CompletableFuture<Object>();
ScheduledFuture future = executor.scheduleWithFixedDelay(() -> poll(jobId, result), 0, 10, TimeUnit.SECONDS);

public void poll(String jobId, CompletableFuture<Object> result) {
   boolean jobDone = remoteServer.isJobDone(jobId);
   if (jobDone) {
       retrieveJobResult(jobId, …

在C#中,Task类有ContinueWith方法,当任务运行完成状态时,ContinueWith方法将被调用,而在JAVA中,是否有一些方法如ContinueWith？

我知道番石榴listenablefuture,但它使用一个新的线程来等待'任务'完成,它是否等于C# ContinueWith？

和JAVA 8 具有相同的效果,那么C#的区别是 什么？CompletableFuture whenCompleteContinueWith listenablefuture CompletableFuture

谢谢!

我需要缓存一些异步计算的结果.详细地说,为了克服这个问题,我试图使用Spring 4.3缓存和异步计算功能.

举个例子,我们来看下面的代码:

@Service
class AsyncService {
    @Async
    @Cacheable("users")
    CompletableFuture<User> findById(String usedId) {
        // Some code that retrieves the user relative to id userId
        return CompletableFuture.completedFuture(user);
    }
}

可能吗？我的意思是,Spring的缓存抽象是否会正确处理类型的对象CompletableFuture<User>？我知道Caffeine Cache有类似的东西,但是我无法理解如果Spring正确配置它是否会使用它.

编辑:我对User对象本身不感兴趣,但是CompletableFuture代表了计算.

我创建了一个自定义 ExecutorService

ExecutorService executor =
        new ThreadPoolExecutor(0, maxPoolSize, keepAliveTime, timeUnit, new LinkedBlockingDeque<>());

我提交我的任务

Future<String> result = executor.submit(() -> "test");

如你所见,执行者返回微薄Future; 我宁愿拥有一个CompletableFuture可以和其他人联系CompletableFuture的东西.

在番石榴,我们有ListeningExecutorService返回ListenableFutures.ListenableFuture根据我的意图和目的,这些是和CompletableFutures 一样好.

尽管如此,我还是希望尽可能多地使用Java的标准库,这意味着我正在寻找一种CompletableFuture从我的自定义执行器中获取s 的方法.

我的应用程序严重依赖异步Web服务。它是用Spring Boot 1.5.x构建的，它使我可以利用标准Java 8 CompletableFuture<T>来产生延迟的异步响应。有关更多信息，请参见 https://nickebbitt.github.io/blog/2017/03/22/async-web-service-using-completable-future

Spring Boot 2.0.x现在带有可以利用反应范例的入门包。Spring WebFlux是框架，用于实现响应式HTTP。

由于我已经按照第一段所述实现了API，因此通过重做服务以使用非阻塞反应式方法，我能获得很多收益吗？简而言之，我还将拥有非阻塞API，对吧？

有一个例子如何在基于异步API转换CompletableFuture<T>到Mono<T>\Flux<T>？

我当时正在考虑完全摆脱基于servlet的服务器（在我的情况下为Jetty），并选择Netty + Reactor。

不用说，我对整个反应式范式都是陌生的。

我想听听您的意见。

我的同事首选的Java 8编码风格一直在链接异步调用,例如

CompletionStage<E> someMethod() {
    return doSomething().thenCompose(a -> {
      // ...
      return b;
    }).thenCompose(b -> {
      // ...
      return c;
    }).thenCompose(c -> {
      // ...
      return d;
    }).thenApply(d -> {
      // ...
      return e;
    });
}

我有类似上面的内容,但有一个额外的挑战:我需要回忆一些lambda中检索到的值,在后来的lambda中.例如,

CompletionStage<E> someMethod() {
    return doSomething().thenCompose(a -> {
      // ...
      Foo foo = fooDAO.getFoos(a);
      // ...
      return b;
    }).thenCompose(b -> {
      // ...
      return c;
    }).thenCompose(c -> {
      // ...
      Bar bar = barDAO.getBars(foo);
      // ...
      return d;
    }).thenApply(d -> {
      // ... …

我正在使用Java Future类执行连接Oracle数据库的程序。但是有时查询的速度比预期的要慢。我可以通过future.cancel方法取消未来。

假设我通过future.cancel取消了Future线程。查询将在Oracle中停止执行，还是仅应用程序线程将被停止/取消，Oracle查询将继续在数据库端运行。

我们正在提交很多future，但有些提交速度很慢。

在这种情况下的实际行为是什么。

谢谢