本文介绍: 是的,你可以使用并发框架实现重试功能,但需要手动处理线程等待异步任务。// 模拟第三方接口返回状态这里随机生成processing“, “success“, 或 “failure“当你需要不停调用第三方接口,直到返回成功或失败时,可以使用类似的异步重试机制。// 重试间隔为1秒。// 如果是成功或失败状态,则直接返回结果。// 如果返回的状态是处理中,进行重试。// 如果返回的状态仍然是处理中,继续重试。// 如果是成功或失败状态,则直接返回结果。// 如果是成功或失败状态,则退出循环

当你需要不停调用第三方接口,直到返回成功或失败时,可以使用类似的异步重试机制。以下是一个整合了这个要求的简单示例代码

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

public class AsyncRetryThirdPartyApi {

    private static final ExecutorService executorService = Executors.newFixedThreadPool(5);

    public static void main(String[] args) {
        // 模拟调用第三方接口
        CompletableFuture<String> apiCallResult = callThirdPartyApi();

        // 添加重试机制,最多重试3次
        CompletableFuture<String&gt; retryFuture = apiCallResult
                .thenComposeAsync(result -&gt; {
                    if (“processing“.equals(result)) {
                        // 如果返回的状态是处理中,进行重试
                        return retryWithBackoff();
                    } else {
                        // 如果是成功或失败状态,则直接返回结果
                        return CompletableFuture.completedFuture(result);
                    }
                }, executorService);

        // 等待异步任务和重试任务完成
        String finalResult = retryFuture.join();
        System.out.println(“Final Result: ” + finalResult);

        // 关闭线程池
        executorService.shutdown();
    }

    private static CompletableFuture<String&gt; callThirdPartyApi() {
        // 模拟调用第三方接口异步任务
        return CompletableFuture.supplyAsync(() -&gt; {
            // 模拟第三方接口返回的状态,这里随机生成 “processing“, “success“, 或 “failure”
            double random = Math.random();
            if (random < 0.3) {
                returnprocessing“;
            } else if (random < 0.6) {
                returnsuccess“;
            } else {
                returnfailure”;
            }
        }, executorService);
    }

    private static CompletableFuture<String> retryWithBackoff() {
        // 使用指数退避(exponential backoff策略进行重试
        int maxRetries = 3;
        int retryCount = 0;
        long initialDelayMillis = 100; // 初始延迟100毫秒

        CompletableFuture<String> retryLoop = new CompletableFuture<>();
        retryLoop.completeExceptionally(new RuntimeException(“Initial exception“)); // 触发初始重试

        while (retryCount < maxRetries) {
            retryLoop = retryLoop.exceptionally(throwable -> {
                // 打印重试信息
                System.out.println(“Retrying… Attempt ” + (retryCount + 1));

                // 模拟调用第三方接口异步任务
                return callThirdPartyApi();
            }).thenComposeAsync(result -> {
                if (“processing“.equals(result)) {
                    // 如果返回的状态仍然是处理中,继续重试
                    return CompletableFuture.completedFuture(null);
                } else {
                    // 如果是成功或失败状态,则直接返回结果
                    return CompletableFuture.completedFuture(result);
                }
            }, executorService);

            retryCount++;
            initialDelayMillis *= 2; // 每次重试,延迟加倍
            try {
                TimeUnit.MILLISECONDS.sleep(initialDelayMillis);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        return retryLoop;
    }
}

/
是的,你可以不使用并发框架实现重试功能,但需要手动处理线程的等待异步任务。以下是一个简单的例子,使用while循环和Thread.sleep()来实现重试:

public class RetryWithoutConcurrency {

    public static void main(String[] args) {
        int maxRetries = 3;
        int retryCount = 0;
        long retryIntervalMillis = 1000; // 重试间隔为1秒

        String result = null;
        while (retryCount < maxRetries) {
            try {
                result = callThirdPartyApi();
                if (“success“.equals(result) || “failure”.equals(result)) {
                    // 如果是成功或失败状态,则退出循环
                    break;
                } else {
                    System.out.println(“Still processing… Retrying after ” + retryIntervalMillis + ” milliseconds.”);
                    Thread.sleep(retryIntervalMillis);
                }
            } catch (Exception e) {
                System.out.println(“Retrying… Attempt ” + (retryCount + 1));
            }
            retryCount++;
        }

        System.out.println(“Final Result: ” + result);
    }

    private static String callThirdPartyApi() {
        // 模拟调用第三方接口
        double random = Math.random();
        if (random < 0.3) {
            return “processing“;
        } else if (random < 0.6) {
            return “success“;
        } else {
            return “failure”;
        }
    }
}
在这个例子中,callThirdPartyApi方法模拟了调用第三方接口,而主方法通过while循环进行重试。注意,这里使用了Thread.sleep()来等待一定的时间间隔。请注意,这种方法在某些情况下可能不够灵活,因为它是同步的,可能会导致整个线程阻塞。如果你的应用需要更高的并发性能和灵活性,使用并发框架通常是更好选择

原文地址:https://blog.csdn.net/mywaya2333/article/details/134747406

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_24882.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注