重试模式深度指南：构建容错系统的核心艺术

引言

在分布式系统和微服务架构中，网络抖动、服务超时、临时故障是不可避免的现实。当你的服务调用外部API或数据库时，一次失败并不意味着永远失败。重试模式（Retry Pattern）是提升系统弹性的基础架构模式之一，它允许系统在遭遇临时故障时自动尝试恢复。

什么是重试模式？

重试模式是一种容错机制，当操作因临时性故障失败时，系统会自动重新执行操作，而不是立即返回失败。这些临时故障通常包括：

• 网络超时或连接中断
• 服务暂时不可用
• 数据库锁冲突
• 资源暂时耗尽（如连接池满）

重试策略的核心要素

1. 重试次数（Retry Count）

设置最大重试次数是第一步。次数太少可能无法恢复，太多则会造成系统负担和用户体验延迟。一般建议：

• 同步调用：2-3次
• 异步后台任务：3-5次

2. 重试间隔（Retry Interval）

两次重试之间需要等待一段时间，让故障恢复。常见策略包括：

# 固定间隔
delay = 1000  # 1秒

# 指数退避（推荐）
delay = min(base * (2 ** attempt), max_delay)
# 尝试0: 1s, 尝试1: 2s, 尝试2: 4s, 尝试3: 8s...

# 抖动（Jitter）避免惊群效应
delay = delay * (0.5 + random.random())  # ±50%

3. 退避算法

固定延迟：简单但效果一般

指数退避（Exponential Backoff）：每次重试间隔翻倍，推荐用于分布式系统

抖动（Jitter）：在退避时间上增加随机偏移，避免大量请求同时重试导致"惊群效应"

import random
import time

def retry_with_backoff(attempt):
    base_delay = 1  # 基础延迟1秒
    max_delay = 30   # 最大30秒

    # 指数退避
    delay = min(base_delay * (2 ** attempt), max_delay)

    # 添加抖动 (±50%)
    delay = delay * (0.5 + random.random())

    return delay

可重试与不可重试的错误

可以重试的错误

• 网络超时（Timeout）
• 连接拒绝（Connection Refused）
• 503 Service Unavailable
• 429 Too Many Requests（可等待后重试）
• 临时性数据库锁冲突

不应该重试的错误

• 认证失败（401 Unauthorized）
• 权限不足（403 Forbidden）
• 业务逻辑错误（如余额不足）
• 数据格式错误
• 幂等性无法保证的操作

最佳实践

1. 区分临时故障和永久故障

只有临时故障才值得重试：

def is_retryable(error):
    retryable_codes = {
        408,  # Request Timeout
        429,  # Too Many Requests
        500,  # Internal Server Error
        502,  # Bad Gateway
        503,  # Service Unavailable
        504,  # Gateway Timeout
    }
    return error.code in retryable_codes

2. 设置超时限制

防止无限等待：

import signal

class TimeoutException(Exception):
    pass

def with_timeout(func, timeout_seconds):
    def handler(signum, frame):
        raise TimeoutException("Operation timed out")

    signal.signal(signal.SIGALRM, handler)
    signal.alarm(timeout_seconds)
    try:
        return func()
    finally:
        signal.alarm(0)

3. 幂等性设计

重试可能导致操作执行多次，必须保证幂等性：

• 使用唯一请求ID（Request ID）
• 数据库操作使用唯一约束
• 消息队列使用消息去重
• API设计支持idempotency-key

import uuid

def call_with_retry(api_call, max_retries=3):
    request_id = str(uuid.uuid4())
    headers = {"X-Idempotency-Key": request_id}

    for attempt in range(max_retries):
        try:
            return api_call(headers=headers)
        except RetryableError:
            if attempt == max_retries - 1:
                raise
            wait exponential_backoff(attempt)

4. 熔断器集成

重试模式常与熔断器模式配合使用：

class CircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.circuit_open = False
        self.last_failure_time = None
        self.recovery_timeout = recovery_timeout

    def call(self, func):
        if self.circuit_open:
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.circuit_open = False  # 尝试恢复
            else:
                raise CircuitOpenError()

        try:
            result = func()
            self.failure_count = 0
            return result
        except Exception as e:
            self.failure_count += 1
            self.last_failure_time = time.time()
            if self.failure_count >= self.failure_threshold:
                self.circuit_open = True
            raise

代码示例

Python 实现

import time
import random
import functools
from typing import Callable, Type, Tuple

class RetryError(Exception):
    def __init__(self, attempts: int, last_error: Exception):
        self.attempts = attempts
        self.last_error = last_error
        super().__init__(f"Failed after {attempts} attempts: {last_error}")

def retry(
    max_attempts: int = 3,
    base_delay: float = 1.0,
    max_delay: float = 30.0,
    exponential_base: float = 2.0,
    jitter: bool = True,
    retryable_exceptions: Tuple[Type[Exception], ...] = (Exception,)
):
    """重试装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None

            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except retryable_exceptions as e:
                    last_error = e

                    if attempt == max_attempts - 1:
                        raise RetryError(attempt + 1, last_error)

                    # 计算延迟
                    delay = min(base_delay * (exponential_base ** attempt), max_delay)
                    if jitter:
                        delay = delay * (0.5 + random.random())

                    time.sleep(delay)

            raise RetryError(max_attempts, last_error)

        return wrapper
    return decorator

# 使用示例
@retry(max_attempts=3, base_delay=1.0, jitter=True)
def call_external_api():
    response = requests.get("https://api.example.com/data")
    response.raise_for_status()
    return response.json()

Go 实现

func RetryWithBackoff(fn func() error, maxAttempts int) error {
    var err error
    for attempt := 0; attempt < maxAttempts; attempt++ {
        err = fn()
        if err == nil {
            return nil
        }

        if attempt == maxAttempts-1 {
            return err
        }

        // 指数退避 + 抖动
        delay := time.Duration(math.Min(
            float64(time.Second) * math.Pow(2, float64(attempt)),
            float64(30*time.Second)))
        jitter := time.Duration(rand.Int63n(int64(delay / 2)))
        time.Sleep(delay + jitter)
    }
    return err
}

注意事项

1. 避免重试风暴：在分布式系统中，大量重试可能放大故障。使用熔断器和限流保护。

2. 超时设置：总超时时间 = 重试次数 × 单次超时，需要合理规划。

3. 日志记录：记录每次重试的详细信息，便于排查问题。

4. 监控告警：重试次数过多时触发告警，识别潜在系统问题。

5. 用户反馈：同步调用时，提供加载提示；异步任务时，返回任务ID供查询。

总结

重试模式是构建高可用系统的基础架构模式之一。核心要点：

• 识别可重试错误：区分临时故障和永久故障
• 指数退避 + 抖动：避免惊群效应
• 设置上限：防止无限重试
• 幂等性设计：确保重试安全
• 配合熔断器：防止故障放大

合理使用重试模式，可以让系统在面对临时故障时自动恢复，提升整体可用性和用户体验。

---

推荐阅读：

• 《断路器模式深度指南》
• 《微服务架构深度指南》