在 go 中，处理临时性错误有三种常见技术：重试：在遇到错误时多次尝试操作，直到成功或达到重试次数限制。指数退避：重试策略，随着重试次数的增加，重试之间的延迟时间也指数级增加。断路器：限制向服务器发出请求的次数，当错误率达到一定阈值时，断路器会打开，停止发送请求。

Go 框架：如何处理临时性错误

在编写 Go 应用程序时，处理错误至关重要，尤其是当这些错误可能是暂时的或自我修复时的错误。Go 框架提供了多种机制来处理临时性错误，本文将介绍这些技术并通过实际案例加以说明。

重试

立即学习“go语言免费学习笔记（深入）”；

重试是一种简单但有效的处理临时性错误的方法。它涉及在遇到错误时多次尝试相同的操作，直到成功或达到重试次数限制。

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    url := "https://example.com"
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    var client http.Client
    for attempt := 1; attempt <= 5; attempt++ {
        resp, err := client.Get(url)
        if err == nil {
            fmt.Printf("Success after %d attemptsn", attempt)
            resp.Body.Close()
            return
        }

        // 暂停 500 毫秒再重试
        time.Sleep(500 * time.Millisecond)
    }

    fmt.Println("Failed after 5 attempts")
}

指数退避

指数退避是一种重试策略，随着重试次数的增加，重试之间的延迟时间也指数级增加。这有助于防止在遇到临时性错误时过载服务器或导致分布式拒绝服务 (DDoS) 攻击。

import (
    "context"
    "fmt"
    "io"
    "math"
    "net/http"
    "time"
)

func main() {
    url := "https://example.com"
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    var client http.Client
    initialDelay := 100 * time.Millisecond
    for attempt := 1; attempt <= 5; attempt++ {
        resp, err := client.Get(url)
        if err == nil {
            fmt.Printf("Success after %d attemptsn", attempt)
            resp.Body.Close()
            return
        }

        // 指数级增加延迟时间
        delay := time.Duration(initialDelay * math.Pow(2, float64(attempt-1)))
        time.Sleep(delay)
    }

    fmt.Println("Failed after 5 attempts")
}

断路器

断路器是一种限制向服务器发出请求的次数的机制。当错误率达到一定阈值时，断路器会“打开”，停止向服务器发送请求，直到一段时间后才重新尝试连接。

import (
    "context"
    "fmt"
    "io"
    "sync/atomic"
    "net/http"
    "time"
)

type CircuitBreaker struct {
    threshold float64
    open bool
    lastOpened time.Time
}

func NewCircuitBreaker(threshold float64) *CircuitBreaker {
    return &CircuitBreaker{
        threshold: threshold,
        open:      false,
        lastOpened: time.Now(),
    }
}

func (cb *CircuitBreaker) Allow() bool {
    if cb.open {
        // 断路器已打开，检查是否已过去冷却时间
        if time.Since(cb.lastOpened) < 60*time.Second {
            return false
        }

        // 冷却时间已过，重置断路器
        cb.open = false
    }

    return true
}

func main() {
    url := "https://example.com"
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    cb := NewCircuitBreaker(0.5)
    var client http.Client
    for attempt := 1; attempt <= 10; attempt++ {
        if !cb.Allow() {
            fmt.Println("Circuit breaker is open, not sending request")
            continue
        }

        resp, err := client.Get(url)
        if err == nil {
            fmt.Printf("Success after %d attemptsn", attempt)
            resp.Body.Close()
            return
        }

        // 错误，增加错误计数
        atomic.AddUint64(&cb.errors, 1)
    }

    // 错误率达到阈值，打开断路器
    cb.open = true
    cb.lastOpened = time.Now()
}

这些是 Go 框架中处理临时性错误的一些常见技术。通过了解这些机制并将其应用到你的代码中，你可以确保你的应用程序在遇到短暂的错误时仍然具有鲁棒性和可用性。