区分偶发性超时和频繁超时的重试策略

技术 4 分钟阅读

在实际项目中，区分偶发性超时和频繁超时的重试策略非常重要。偶发性超时可能是由于网络抖动或临时负载过高引起的，适合立即重试；而频繁超时则可能是系统过载或下游服务不可用，此时应避免重试，以免加剧问题。

在实际面试的过程中，经常会遇到类似的面试题目，这时候可以这样回答：

在处理大量请求时，我们经常会遇到超时的情况。为了合理控制重试行为，避免所谓的“重试风暴”，我设计了一个基于时间窗口的算法。在这个算法中，我们维护了一个滑动窗口，窗口内记录了每个请求的时间戳以及该请求是否超时。每当一个请求超时后，我们会统计窗口内超时的请求数量。如果超时请求的数量超过了设定的阈值，我们就认为当前系统压力较大，不适合进行重试；否则，我们认为可以安全地进行重试。

然而，随着并发量的增加，普通版的滑动窗口算法暴露出了一些问题。特别是在高并发场景下，窗口内需要维护的请求数量可能非常大，这不仅占用了大量内存，而且在判定是否需要重试时还需要遍历整个窗口，这大大增加了算法的时间复杂度。

为了解决这个问题，我们进一步设计了进阶版的算法。在这个版本中，我们引入了ring buffer 来优化滑动窗口的实现。具体来说，我们不再以时间为窗口大小，而是使用固定数量的比特位来记录请求的超时信息。每个比特位对应一个请求，用1表示超时，用0表示未超时。当所有比特位都被标记后，我们从头开始再次标记。

这种设计极大地降低了内存占用，因为无论并发量多高，我们只需要固定数量的比特位来记录请求的超时状态。同时，在判定是否需要重试时，我们只需要统计ring buffer中为1的比特数量，这大大简化了算法的实现并提高了效率。

这里涉及到以下知识点：

以下是针对偶发性超时和频繁超时的重试策略设计，以及如何在 Java 项目中实现。

1. 重试策略设计

偶发性超时

频繁超时

2. 实现方案

核心思路

3. Java 实现

以下是完整的 Java 实现代码，包括重试策略和熔断机制。

1、创建滑动窗口统计器

使用 ring buffer 和 AtomicInteger 实现线程安全的滑动窗口。

public class RequestStatusTracker {
    private final int windowSize; / 滑动窗口大小
    private final double failureRateThreshold; / 失败率阈值（触发熔断）
    private final long circuitBreakerOpenTime; / 熔断器打开时间（毫秒）
    private final int halfOpenRequests; / 半开状态下允许的请求数
    private final int[] ringBuffer; / 环形缓冲区
    private final AtomicInteger currentIndex = new AtomicInteger(0); / 当前写入位置
    private final AtomicInteger successCount = new AtomicInteger(0); / 成功请求计数
    private final AtomicInteger failureCount = new AtomicInteger(0); / 失败请求计数
    private final AtomicLong circuitBreakerOpenedTime = new AtomicLong(0); / 熔断器打开时间
    private final AtomicInteger halfOpenSuccessCount = new AtomicInteger(0); / 半开状态下的成功请求计数
    private volatile CircuitBreakerState circuitBreakerState = CircuitBreakerState.CLOSED; / 熔断器状态


    / 熔断器状态枚举
    private enum CircuitBreakerState {
        CLOSED, OPEN, HALF_OPEN
    }


    public RequestStatusTracker(int windowSize, double failureRateThreshold, long circuitBreakerOpenTime, int halfOpenRequests) {
        if (windowSize <= 0 || failureRateThreshold < 0 || failureRateThreshold > 1 || circuitBreakerOpenTime <= 0 || halfOpenRequests <= 0) {
            throw new IllegalArgumentException("Invalid parameters");
        }
        this.windowSize = windowSize;
        this.failureRateThreshold = failureRateThreshold;
        this.circuitBreakerOpenTime = circuitBreakerOpenTime;
        this.halfOpenRequests = halfOpenRequests;
        this.ringBuffer = new int[windowSize]; / 0: 成功, 1: 失败
    }


    / 记录请求状态
    public void recordRequest(boolean isSuccess) {
        synchronized (this) {
            int index = currentIndex.getAndUpdate(i -> (i + 1) % windowSize);
            if (ringBuffer[index] == 0) {
                successCount.decrementAndGet();
            } else if (ringBuffer[index] == 1) {
                failureCount.decrementAndGet();
            }


            if (isSuccess) {
                ringBuffer[index] = 0;
                successCount.incrementAndGet();
            } else {
                ringBuffer[index] = 1;
                failureCount.incrementAndGet();
            }


            / 更新熔断器状态
            updateCircuitBreakerState();
        }
    }


    / 更新熔断器状态
    private void updateCircuitBreakerState() {
        double failureRate = (double) failureCount.get() / windowSize;
        long now = System.currentTimeMillis();


        switch (circuitBreakerState) {
            case CLOSED:
                if (failureRate >= failureRateThreshold) {
                    / 触发熔断
                    circuitBreakerState = CircuitBreakerState.OPEN;
                    circuitBreakerOpenedTime.set(now);
                }
                break;
            case OPEN:
                if (now - circuitBreakerOpenedTime.get() >= circuitBreakerOpenTime) {
                    / 进入半开状态
                    circuitBreakerState = CircuitBreakerState.HALF_OPEN;
                    halfOpenSuccessCount.set(0);
                }
                break;
            case HALF_OPEN:
                / 半开状态下，成功请求数达到阈值后关闭熔断器
                if (halfOpenSuccessCount.get() >= halfOpenRequests) {
                    circuitBreakerState = CircuitBreakerState.CLOSED;
                }
                break;
        }
    }


    / 判断是否允许请求
    public boolean allowRequest() {
        if (circuitBreakerState == CircuitBreakerState.OPEN) {
            return false; / 熔断器打开，禁止请求
        } else if (circuitBreakerState == CircuitBreakerState.HALF_OPEN) {
            / 半开状态下，允许部分请求
            return halfOpenSuccessCount.get() < halfOpenRequests;
        }
        return true; / 熔断器关闭，允许请求
    }


    / 获取当前熔断器状态
    public String getCircuitBreakerState() {
        return circuitBreakerState.name();
    }


   / 判断熔断器是否打开
    public boolean isCircuitBreakerOpen() {
        return !CircuitBreakerState.CLOSED.equals(circuitBreakerState);
    }


    / 获取当前窗口内的失败率
    public double getFailureRate() {
        return (double) failureCount.get() / windowSize;
    }
}

熔断器状态

熔断器参数

2、在服务层调用外部 API 时，使用 RequestStatusTracker 控制重试行为。

@Service
public class UserService {


    @Autowired
    private RestTemplate restTemplate;


    @Autowired
    private RequestStatusTracker requestStatusTracker;


    / 调用外部 API 获取用户信息
    public String getUserInfo(String userId) {
        String url = "https://api.example.com/users/" + userId;
        try {
            / 发送请求
            String response = restTemplate.getForObject(url, String.class);


            / 记录请求成功（未超时）
            requestStatusTracker.recordRequest(false);
            return response;
        } catch (Exception e) {
            / 记录请求失败（超时）
            requestStatusTracker.recordRequest(true);


            / 判断是否允许重试
            if (requestStatusTracker.allowRequest()) {
                / 偶发性超时，立即重试
                return getUserInfo(userId);
            } else {
                / 频繁超时，禁止重试
                throw new RuntimeException("Request failed and retry is not allowed due to high timeout rate");
            }
        }
    }
}

3、在服务层如果是调用 Feign 客户端时，创建 Feign 请求拦截器。

@Configuration
public class FeignConfig {
    @Bean
    public ErrorDecoder errorDecoder(RequestStatusTracker tracker) {
        return (methodKey, response) -> {
            / 记录请求失败
            tracker.recordRequest(false);
            return new RuntimeException("Feign request failed with status: " + response.status());
        };
    }


    @Bean
    public feign.Logger.Level feignLoggerLevel() {
        return feign.Logger.Level.FULL; / 启用详细日志
    }
}

在 Feign 客户端中，通过 @FeignClient 注解配置拦截器。

@FeignClient(name = "userService", url = "https://api.example.com", configuration = FeignConfig.class)
public interface UserServiceClient {


    @GetMapping("/users/{userId}")
    String getUserInfo(@PathVariable String userId);
}

在服务层调用 Feign 客户端时，结合熔断器策略控制请求。

@Service
public class UserService {


    @Autowired
    private UserServiceClient userServiceClient;


    @Autowired
    private RequestStatusTracker tracker;


    public String getUserInfo(String userId) {
        / 检查是否允许请求
        if (!tracker.allowRequest()) {
            throw new RuntimeException("Circuit breaker is open. Request is not allowed.");
        }


        try {
            String response = userServiceClient.getUserInfo(userId);
            / 记录请求成功
            tracker.recordRequest(true);
            return response;
        } catch (Exception e) {
            / 记录请求失败
            tracker.recordRequest(false);
            throw new RuntimeException("Request failed: " + e.getMessage());
        }
    }
}

4、在 Spring Boot 的配置文件中，配置熔断器参数。

app:
  request:
    window-size: 100 # 滑动窗口大小
    failure-rate-threshold: 0.5 # 失败率阈值（50%）
    circuit-breaker-open-time: 10000 # 熔断器打开时间（10秒）
    half-open-requests: 5 # 半开状态下允许的请求数

在代码中读取配置：

@Configuration
public class AppConfig {


    @Value("${app.request.window-size}")
    private int windowSize;


    @Value("${app.request.failure-rate-threshold}")
    private double failureRateThreshold;


    @Value("${app.request.circuit-breaker-open-time}")
    private long circuitBreakerOpenTime;


    @Value("${app.request.half-open-requests}")
    private int halfOpenRequests;


    @Bean
    public RequestStatusTracker requestStatusTracker() {
        return new RequestStatusTracker(windowSize, failureRateThreshold, circuitBreakerOpenTime, halfOpenRequests);
    }
}

5、熔断器状态监控

@Component
public class CircuitBreakerMonitor {


    @Autowired
    private RequestStatusTracker requestStatusTracker;


    @Scheduled(fixedRate = 5000) / 每 5 秒检查一次
    public void monitor() {
        if (requestStatusTracker.isCircuitBreakerOpen()) {
            System.out.println("Circuit breaker is open! Please check the downstream service.");
            / 触发告警逻辑
        }
    }
}

订阅文章

订阅更新，不错过后续文章

直接通过 RSS 和 Telegram 订阅本站更新。

订阅 RSS关注 Telegram

分享文章

如果这篇有帮助，可以顺手转发

直接分享给同事、朋友，或者发到你的社交平台。

分享到 X 分享到 Telegram 邮件分享

相关文章

技术

在 GitHub CodeSpace 中安装和使用 OpenClaw

本文介绍在 Codespaces 中从安装到正常使用的完整步骤。

技术

linkding 合并 linkding-cn 代码

本文将详细介绍如何将 linkding-cn 的优秀功能迁移到最新的 Linkding 项目中，包括项目对比、可行性分析、迁移过程以及最终的

技术

Spring Boot 2 升级到 Spring Boot 3 指南

本文介绍如何使用 OpenRewrite 自动化迁移 Spring Boot 2.7.x 应用到 Spring Boot 3.x，以及如何使用 spring-boot-2-to-3 这个 AI Agent Skill 来简化升级流程。

技术

Claude Code 安装、配置、使用与认证指南

全面介绍 Claude Code 的安装、配置、使用与认证方式，并补充订阅方案和通过 OpenRouter 接入的实践路径。

技术

OpenClaw 安装、配置与使用指南

OpenClaw 开源个人 AI 助手，可接 Telegram/WhatsApp/Discord 等。从安装、配置到使用与渠道，由浅入深。

技术

Codex CLI 安装、配置、使用与认证指南

全面介绍 Codex CLI 的安装、配置、使用与认证方式，帮助在终端中接入 OpenAI 的本地化 AI 编程助手。

如何实现榜单 Top N 统计
限流是什么：原理、目的与常见方案