什么是指数退避算法（或者策略）？

// 糟糕的重试方式 - 固定间隔
async function badRetry() {
  for (let i = 0; i < 5; i++) {
    try {
      return await callAPI();
    } catch (error) {
      await sleep(1000); // 总是等待1秒
    }
  }
}

问题分析：

如果服务需要10秒恢复，前9次重试都太早

大量客户端同时重试，服务器压力更大

没有给服务足够的恢复时间

所以：

避免雪崩效应：如果所有客户端在服务出现问题时立即重试，可能会形成“重试风暴”，进一步加重服务器负担。
给服务恢复时间：随着重试次数的增加，等待时间变长，这给了服务更多的时间来恢复。
平衡延迟和负载：在服务不可用时，快速重试可能没有意义，而指数退避可以在不过分增加延迟的情况下减少不必要的请求。

算法步骤

设定初始延迟（如1秒）和最大延迟（如30秒）。

第一次重试等待初始延迟时间。

每次重试后，将等待时间乘以2（指数增长）。

当等待时间超过最大延迟时，使用最大延迟。

通常还会加入随机抖动（jitter）来避免多个客户端同时重试。

公式

等待时间 = min(初始延迟 * (2 ^ 重试次数), 最大延迟) + 随机抖动

// 优秀的重试方式 - 指数退避
async function goodRetry() {
  for (let i = 0; i < 5; i++) {
    try {
      return await callAPI();
    } catch (error) {
      const delay = 1000 * Math.pow(2, i); // 1s, 2s, 4s, 8s, 16s
      await sleep(delay);
    }
  }
}

优势：

智能等待：给服务越来越长的恢复时间

避免拥塞：分散客户端重试压力

成本效益：在成功率和资源消耗间取得平衡

具体计算过程

// 参数设置
const baseDelay = 1000;  // 基础延迟1秒
const maxRetries = 5;    // 最大重试5次

// 各次重试的等待时间计算：
function calculateWaitTime(retryCount) {
  return baseDelay * Math.pow(2, retryCount);
}

// 计算结果：
console.log("第1次重试等待:", calculateWaitTime(0)); // 1000ms (1秒)
console.log("第2次重试等待:", calculateWaitTime(1)); // 2000ms (2秒)  
console.log("第3次重试等待:", calculateWaitTime(2)); // 4000ms (4秒)
console.log("第4次重试等待:", calculateWaitTime(3)); // 8000ms (8秒)
console.log("第5次重试等待:", calculateWaitTime(4)); // 16000ms (16秒)

下面是一个完整的指数退避实现

包括随机抖动和最大重试次数限制。

关键参数：

baseDelay：基础等待时间

maxDelay：最大等待时间（防止无限增长）

jitterFactor：随机抖动系数（避免同步）

maxRetries：最大重试次数

/**
 * 指数退避重试函数
 * @param {Function} requestFn - 要重试的请求函数
 * @param {Object} options - 配置选项
 * @param {number} options.maxRetries - 最大重试次数，默认为5
 * @param {number} options.baseDelay - 基础延迟（毫秒），默认为1000
 * @param {number} options.maxDelay - 最大延迟（毫秒），默认为30000
 * @param {number} options.jitter - 随机抖动因子（0到1之间），默认为0.1
 * @returns {Promise} - 请求结果的Promise
 */
async function exponentialBackoffRetry(requestFn, options = {}) {
    const {
        maxRetries = 5,
        baseDelay = 1000,
        maxDelay = 30000,
        jitter = 0.1
    } = options;

    let retryCount = 0;

    while (true) {
        try {
            // 尝试执行请求函数
            return await requestFn();
        } catch (error) {
            retryCount++;

            // 如果达到最大重试次数，抛出错误
            if (retryCount > maxRetries) {
                throw new Error(`达到最大重试次数: ${error.message}`);
            }

            // 计算本次重试的延迟时间
            let delay = Math.min(baseDelay * Math.pow(2, retryCount - 1), maxDelay);

            // 添加随机抖动
            if (jitter > 0) {
                const jitterValue = delay * jitter * Math.random();
                delay += jitterValue;
            }

            console.log(`请求失败。正在重试 ${delay.toFixed(2)}ms. 尝试${retryCount}/${maxRetries}`);

            // 等待延迟时间
            await new Promise(resolve => setTimeout(resolve, delay));
        }
    }
}

详细说明

初始设置：我们设置了最大重试次数、基础延迟、最大延迟和抖动因子。

重试循环：使用while(true)循环，直到请求成功或达到最大重试次数。

错误处理：捕获错误后，先检查是否已经达到最大重试次数，如果是则抛出错误。

计算延迟：根据重试次数计算延迟时间，并确保不超过最大延迟。

添加抖动：为了避免多个客户端同时重试，我们添加了一个随机抖动，这样每个客户端的重试时间会稍有不同。

等待：使用setTimeout等待计算出的延迟时间，然后继续重试。

抖动因子的作用

抖动因子是为了避免多个客户端在相同的时间点进行重试。例如，如果多个客户端同时遇到失败，它们可能会在相同的时间间隔后重试，从而导致再次同时冲击服务器。通过添加随机抖动，我们可以让每个客户端的重试时间稍微分散，从而减轻服务器压力。

假设我们有一个可能会失败的API调用：

// 模拟一个可能失败的请求
function simulateRequest() {
    return new Promise((resolve, reject) => {
        const random = Math.random();
        if (random > 0.8) { // 80%的失败率
            resolve({ data: 'Success!' });
        } else {
            reject(new Error('临时请求失败'));
        }
    });
}

// 使用指数退避重试
exponentialBackoffRetry(simulateRequest, {
    maxRetries: 5,
    baseDelay: 1000,
    maxDelay: 30000,
    jitter: 0.1
})
    .then(result => {
        console.log('请求成功:', result);
    })
    .catch(error => {
        console.error('重试后请求失败:', error);
    });

应用场景：

1. API调用重试

class ApiClient {
  constructor() {
    this.backoff = new ProductionExponentialBackoff(1000, 30000);
  }
  
  async callApi(url, options = {}) {
    return this.backoff.executeWithRetry(async () => {
      const response = await fetch(url, options);
      
      if (!response.ok) {
        // 只有5xx错误才重试
        if (response.status >= 500) {
          throw new Error(`服务器错误: ${response.status}`);
        }
        // 4xx错误不重试
        throw new Error(`客户端错误: ${response.status}`);
      }
      
      return response.json();
    }, 3); // 最多重试3次
  }
}

2. WebSocket重连

class WebSocketManager {
  constructor(url) {
    this.url = url;
    this.reconnectAttempts = 0;
    this.backoff = new ProductionExponentialBackoff(1000, 60000);
  }
  
  connect() {
    this.ws = new WebSocket(this.url);
    
    this.ws.onopen = () => {
      console.log('WebSocket连接成功');
      this.reconnectAttempts = 0; // 重置重连计数
    };
    
    this.ws.onclose = (event) => {
      console.log('WebSocket连接断开');
      this.scheduleReconnect();
    };
  }
  
  async scheduleReconnect() {
    try {
      await this.backoff.executeWithRetry(async () => {
        return new Promise((resolve, reject) => {
          this.connect();
          // 这里需要更复杂的逻辑来检测连接是否真正成功
          setTimeout(resolve, 1000); // 简化示例
        });
      }, 5);
    } catch (error) {
      console.error('WebSocket重连失败');
    }
  }
}

不同场景的配置：

// 快速响应的API
const fastApiConfig = {
  baseDelay: 500,    // 0.5秒
  maxDelay: 5000,    // 5秒上限
  maxRetries: 3      // 重试3次
};

// 慢速服务
const slowServiceConfig = {
  baseDelay: 2000,   // 2秒
  maxDelay: 60000,   // 60秒上限  
  maxRetries: 5      // 重试5次
};

// 高并发场景（抖动更重要）
const highConcurrencyConfig = {
  baseDelay: 1000,
  maxDelay: 30000,
  jitterFactor: 0.3, // 30%抖动，分散压力
  maxRetries: 4
};