Golang中对于可重试的临时性错误应该如何设计处理策略

context.Context

delay

attempt

baseDelay

maxDelay

maxAttempts

delay = baseDelay * (2 ^ attempt)

[0, calculated_delay]

[0, half_delay]

package main

import (
    "context"
    "fmt"
    "math"
    "math/rand"
    "time"
)

// RetryableFunc 模拟一个可能失败的函数
func RetryableFunc(attempt int) error {
    if attempt < 3 { // 模拟前三次失败
        return fmt.Errorf("temporary error on attempt %d", attempt)
    }
    fmt.Printf("Attempt %d: Success!\n", attempt)
    return nil
}

// ExponentialBackoffWithJitter 实现指数退避和抖动
func ExponentialBackoffWithJitter(
    ctx context.Context,
    maxAttempts int,
    baseDelay time.Duration,
    maxDelay time.Duration,
    operation func(attempt int) error,
) error {
    var err error
    for i := 0; i < maxAttempts; i++ {
        err = operation(i + 1) // attempt starts from 1
        if err == nil {
            return nil // 成功，直接返回
        }

        fmt.Printf("Attempt %d failed: %v\n", i+1, err)

        // 如果不是最后一次尝试，则计算并等待退避时间
        if i < maxAttempts-1 {
            // 计算基础指数退避时间
            calculatedDelay := baseDelay * time.Duration(math.Pow(2, float64(i)))
            if calculatedDelay > maxDelay {
                calculatedDelay = maxDelay
            }

            // 引入全抖动：在 [0, calculatedDelay] 范围内随机选择
            jitteredDelay := time.Duration(rand.Int63n(int64(calculatedDelay)))

            fmt.Printf("Waiting for %v before next retry...\n", jitteredDelay)

            select {
            case <-ctx.Done():
                fmt.Println("Context cancelled, stopping retries.")
                return ctx.Err()
            case <-time.After(jitteredDelay):
                // 继续下一次循环
            }
        }
    }
    return fmt.Errorf("all %d attempts failed: %w", maxAttempts, err)
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    err := ExponentialBackoffWithJitter(
        ctx,
        5,                   // 最大重试次数
        100*time.Millisecond, // 基础延迟
        2*time.Second,       // 最大延迟
        RetryableFunc,
    )

    if err != nil {
        fmt.Printf("Final error: %v\n", err)
    }
}

context.Context

sony/gobreaker

package main

import (
    "context"
    "errors"
    "fmt"
    "net/http"
    "time"

    "github.com/sony/gobreaker"
)

// MockExternalService 模拟一个外部服务，可能失败
func MockExternalService(fail bool) error {
    if fail {
        return errors.New("external service is currently unavailable")
    }
    // 模拟成功响应
    time.Sleep(50 * time.Millisecond) // 模拟一些延迟
    return nil
}

func main() {
    // 配置熔断器
    settings := gobreaker.Settings{
        Name:        "ExternalServiceBreaker",
        MaxRequests: 3, // 半开状态下允许通过的最大请求数
        Interval:    5 * time.Second, // 统计周期
        Timeout:     10 * time.Second, // 熔断器打开后，多长时间进入半开状态
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            // 失败率超过60%且至少有5个请求时跳闸
            return counts.Requests >= 5 && float64(counts.Failure)/float64(counts.Requests) >= 0.6
        },
        OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
            fmt.Printf("Circuit Breaker '%s' changed from %s to %s\n", name, from, to)
        },
    }
    cb := gobreaker.NewCircuitBreaker(settings)

    fmt.Println("--- Testing Circuit Breaker ---")

    // 模拟连续失败，触发熔断
    for i := 0; i < 10; i++ {
        fmt.Printf("Attempt %d: ", i+1)
        err := cb.Do(func() (interface{}, error) {
            // 这里放置对外部服务的实际调用
            // 模拟前8次失败，后2次成功（如果熔断器未打开）
            if i < 8 {
                return nil, MockExternalService(true)
            }
            return nil, MockExternalService(false)
        })

        if err != nil {
            if errors.Is(err, gobreaker.ErrOpenState) {
                fmt.Printf("Circuit Breaker is OPEN, fast-failing. Error: %v\n", err)
            } else {
                fmt.Printf("Service call failed: %v\n", err)
            }
        } else {
            fmt.Println("Service call succeeded.")
        }
        time.Sleep(500 * time.Millisecond) // 每次尝试之间稍作等待
    }

    fmt.Println("\n--- Waiting for Circuit Breaker to Half-Open ---")
    time.Sleep(settings.Timeout + 1*time.Second) // 等待熔断器从打开状态进入半开状态

    // 模拟半开状态下的尝试
    for i := 0; i < 5; i++ {
        fmt.Printf("Half-Open Attempt %d: ", i+1)
        err := cb.Do(func() (interface{}, error) {
            // 假设服务已经恢复
            return nil, MockExternalService(false)
        })

        if err != nil {
            if errors.Is(err, gobreaker.ErrOpenState) {
                fmt.Printf("Circuit Breaker is OPEN again. Error: %v\n", err)
            } else {
                fmt.Printf("Service call failed: %v\n", err)
            }
        } else {
            fmt.Println("Service call succeeded.")
        }
        time.Sleep(500 * time.Millisecond)
    }
}

context.Context

context.Context

context.Context

context.Context