1
package backoff
2

3
import (
4
  "context"
5
  "errors"
6
  "math"
7
  "math/rand"
8
  "time"
9
)
10

11
type Config struct {
12
  MaxRetries int           // 最大重试次数
13
  BaseDelay  time.Duration // 基础延迟
14
  MaxDelay   time.Duration // 单次延迟上限
15
  Jitter     float64       // 抖动比例 (0-1)
16
}
17

18
// Retry 带指数退避的重试
19
func Retry(fn func() error, cfg Config) error {
20
  var lastErr error
21
  for attempt := 0; attempt <= cfg.MaxRetries; attempt++ {
22
    lastErr = fn()
23
    if lastErr == nil {
24
      return nil // 成功，返回
25
    }
26
    if attempt == cfg.MaxRetries {
27
      break // 最后一次也失败了，不再等待
28
    }
29

30
    // 计算指数延迟 + 抖动
31
    exp := float64(cfg.BaseDelay) * math.Pow(2, float64(attempt))
32
    jitter := exp * cfg.Jitter * rand.Float64()
33
    delay := time.Duration(math.Min(exp+jitter, float64(cfg.MaxDelay)))
34

35
    time.Sleep(delay)
36
  }
37
  return lastErr
38
}
39

40
// RetryWithContext 支持上下文取消的重试
41
func RetryWithContext(ctx context.Context, fn func() error, cfg Config) error {
42
  var lastErr error
43
  for attempt := 0; attempt <= cfg.MaxRetries; attempt++ {
44
    select {
45
    case <-ctx.Done():
46
      return ctx.Err() // 上下文取消，立即返回
47
    default:
48
    }
49

50
    lastErr = fn()
51
    if lastErr == nil {
52
      return nil
53
    }
54
    if attempt == cfg.MaxRetries {
55
      break
56
    }
57

58
    exp := float64(cfg.BaseDelay) * math.Pow(2, float64(attempt))
59
    jitter := exp * cfg.Jitter * rand.Float64()
60
    delay := time.Duration(math.Min(exp+jitter, float64(cfg.MaxDelay)))
61

62
    select {
63
    case <-ctx.Done():
64
      return ctx.Err()
65
    case <-time.After(delay):
66
      // 等待结束，继续重试
67
    }
68
  }
69
  return lastErr
70
}
71

72
// 可重试错误集合
73
var (
74
  ErrTimeout      = errors.New("timeout")
75
  ErrRateLimited  = errors.New("rate limited")
76
  ErrUnavailable  = errors.New("service unavailable")
77
  ErrBadRequest   = errors.New("bad request")
78
  ErrUnauthorized = errors.New("unauthorized")
79
)
80

81
// RetryableError 判断错误是否可重试
82
func RetryableError(err error) bool {
83
  // 瞬时错误 → 可重试
84
  // 429/503/超时 → 可重试
85
  // 400/401/403 → 不可重试
86
  return errors.Is(err, ErrTimeout) ||
87
    errors.Is(err, ErrRateLimited) ||
88
    errors.Is(err, ErrUnavailable)
89
}

1
interface BackoffConfig {
2
  maxRetries: number;    // 最大重试次数
3
  baseDelay: number;     // 基础延迟（毫秒）
4
  maxDelay: number;      // 单次延迟上限
5
  jitter: number;        // 抖动比例 (0-1)
6
}
7

8
async function retryWithBackoff<T>(
9
  fn: () => Promise<T>,
10
  config: BackoffConfig = {
11
    maxRetries: 5,
12
    baseDelay: 1000,
13
    maxDelay: 30000,
14
    jitter: 0.5,
15
  },
16
): Promise<T> {
17
  let lastError: Error | undefined;
18

19
  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
20
    try {
21
      return await fn();
22
    } catch (err) {
23
      lastError = err as Error;
24
      if (attempt === config.maxRetries) break;
25

26
      // 指数延迟 + 随机抖动
27
      const exponential = config.baseDelay * Math.pow(2, attempt);
28
      const jitter = exponential * config.jitter * Math.random();
29
      const delay = Math.min(exponential + jitter, config.maxDelay);
30

31
      await new Promise((r) => setTimeout(r, delay));
32
    }
33
  }
34

35
  throw lastError;
36
}