可靠性的 CompletableFuture 递归

Question

这是CompletableFuture 的非常基本的递归，我想做一个可靠的系统，所以每次都遇到异常重新启动进程，我相信它有太多问题并希望得到你的反馈

private CompletableFuture<?> recursion() {
return CompletableFuture.runAsync(() -> {
    //code here
    }).handleAsync((v, th) -> {
        if (th != null)
            return this.recursion();
        else
            return v;
    });
}

编辑1：

int tries =5;
private CompletableFuture<?> recursion() {
    return CompletableFuture.runAsync(() -> {
    //code here
    }).handleAsync((v, th) -> {
        if (th != null && tries-- > 0){
            Thread.sleep(1000);
            return this.recursion();
        }else
            return v;
    });
}

编辑2： 清理代码作为返回 CompletableFuture<?> 没有必要因此将其挂起以返回 void 考虑 @Holger 评论并使用 AtomicInteger 进行尝试

AtomicInteger tries =5;
private void recursion() {
    CompletableFuture.runAsync(() -> {
    //code here
    }).whenCompleteAsync((v, th) -> {
        if (th != null && ( tries.getAndDecrement() > 0 ) ){
            Thread.sleep(1000);
            this.recursion();
        });
}

请给我反馈，我在争论，但真的很感激。

Answer 1

一般情况下，发生异常时简单地重试操作，而不处理异常来分析失败原因，离创建可靠的系统还很远。

但是，如果您想实现重试，您的代码将无法正确执行此操作。

您的代码恰好被编译器接受，因为您使用了一个不会产生值并返回 CompletableFuture<?> 的操作。这隐藏了您的代码的问题：

传递给handleAsync 的双函数应该提供结果值，但您调用this.recursion() 会产生CompletableFuture<?>。编译器不介意在非异常情况下返回v，因为Void 和CompletableFuture<?> 有一个共同的超类型Object，所以整个方法实际上是返回一个CompletableFuture<Object>兼容返回类型CompletableFuture<?>。

如果您将返回类型声明为CompletableFuture<Void>，则可以立即识别出逻辑错误：在特殊情况下，您正在启动另一个异步操作，但由于您没有检查它的结果而只是返回一个CompletableFuture<?>，然后被视为Object，调用者将永远不会注意到重试（或后续重试）是否失败。调用者将始终收到一个报告成功的CompletableFuture<?>，并将(Void)null 或CompletableFuture<?> 作为结果值。

一般来说，你不应该使用递归来进行重复。没有理由这样做。让我们用一个返回值的动作来演示逻辑：

CompletableFuture<String> performAsyncAction() {
    Supplier<String> action=() -> {
        if(Math.random()>0.2)
            throw new IllegalStateException("simulated failure");
        return "value implying success";
    };
    int retries=5;
    return CompletableFuture.supplyAsync(() -> {
        try { return action.get(); }
        catch(Throwable t) {
            for(int i=0; i<retries; i++) try {
                Thread.sleep(1000);
                return action.get();
            } catch(Throwable next) { t.addSuppressed(next); }
            throw t;
        }
    });
}

很容易适应使用Runnable、runAsync 和CompletableFuture<Void>。

---

更新：如果您只想安排重试而不向发起者提供反馈，您可以通过等待延迟过去来实现它而不阻塞线程：

static ScheduledExecutorService e = Executors.newSingleThreadScheduledExecutor();

static void performAsyncAction(Runnable r, int tries, long delay, TimeUnit u) {
    if(tries>0)
        e.execute(()-> { try { r.run(); } catch(Throwable t) {
            e.schedule(()->performAsyncAction(r, tries-1, delay, u), delay, u);
        }});
}

这使用递归，因为它解决了 lambda 表达式。如果您使用内部类，同样可以在没有递归的情况下工作：

static ScheduledExecutorService e = Executors.newSingleThreadScheduledExecutor();

static void performAsyncAction(Runnable r, int tries, long delay, TimeUnit u) {
    if(tries>0)
        e.execute(new Runnable() {
            int left = tries;
            public void run() {
                try { r.run(); } catch(Throwable t) {
                    if(--left > 0) e.schedule(this, delay, u);
                }
            }
        });
}