golang实现高级功能重试机制插件库retry的使用

Golang实现高级功能重试机制插件库retry的使用

简介

retry是一个高级的可中断重试机制库，用于重复执行操作直到成功。它基于Rican7/retry但完全重构，专注于与breaker库和内置context包的集成。

安装

使用go modules安装最新版本：

go get github.com/kamilsk/retry/v5@latest

核心功能

retry提供了以下高级功能：

  • 可中断的重试机制
  • 与context集成
  • 多种重试策略组合
  • 支持退避算法和抖动

使用示例

下面是一个完整的HTTP请求重试示例：

package main

import (
	"context"
	"log"
	"math/rand"
	"net/http"
	"time"

	"github.com/kamilsk/retry/v5"
	"github.com/kamilsk/retry/v5/backoff"
	"github.com/kamilsk/retry/v5/jitter"
	"github.com/kamilsk/retry/v5/strategy"
)

func main() {
	// 创建带有超时的context
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	// 准备HTTP请求
	req, err := http.NewRequest("GET", "https://example.com", nil)
	if err != nil {
		log.Fatal(err)
	}

	// 定义要重试的操作
	action := func(ctx context.Context) (err error) {
		req := req.Clone(ctx) // 为每次重试创建新的请求副本
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			return err
		}
		defer resp.Body.Close()
		// 这里可以添加对响应状态码的检查
		return nil
	}

	// 定义重试策略
	how := []retry.How{
		strategy.Limit(5), // 最多重试5次
		strategy.BackoffWithJitter(
			backoff.Fibonacci(10*time.Millisecond), // 使用斐波那契退避算法，初始间隔10ms
			jitter.NormalDistribution( // 添加正态分布抖动
				rand.New(rand.NewSource(time.Now().UnixNano())),
				0.25, // 抖动系数
			),
		),
	}

	// 执行重试操作
	if err := retry.Do(ctx, action, how...); err != nil {
		log.Fatal(err)
	}
}

重试策略说明

示例中使用了两种重试策略的组合：

  1. strategy.Limit(5) - 限制最大重试次数为5次
  2. strategy.BackoffWithJitter - 组合退避算法和抖动
    • backoff.Fibonacci - 斐波那契退避算法，每次重试间隔呈斐波那契数列增长
    • jitter.NormalDistribution - 正态分布抖动，避免多个客户端同时重试造成的"惊群效应"

适用场景

retry特别适合以下场景：

  • 分布式系统间的网络通信
  • 调用可能暂时不可用的外部服务
  • 需要处理瞬时故障的操作

该库由Lazada和Avito的前工程师开发，专为提高分布式系统通信的可靠性而设计。


更多关于golang实现高级功能重试机制插件库retry的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang实现高级功能重试机制插件库retry的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang 高级重试机制插件库 retry 的使用

在分布式系统中，网络请求、服务调用等操作经常会因为各种原因失败，良好的重试机制可以提高系统的健壮性。下面介绍如何使用 Go 实现高级重试功能。

1. 基本重试实现

首先我们看一个简单的重试实现：

package retry

import (
	"errors"
	"time"
)

// Retry 简单重试函数
func Retry(attempts int, sleep time.Duration, fn func() error) error {
	var err error
	for i := 0; i < attempts; i++ {
		if i > 0 {
			time.Sleep(sleep)
			sleep *= 2 // 指数退避
		}
		err = fn()
		if err == nil {
			return nil
		}
	}
	return err
}

使用方式：

err := retry.Retry(3, time.Second, func() error {
    // 业务逻辑
    return someOperation()
})

2. 高级重试库推荐

对于更复杂的场景，推荐使用以下成熟的重试库：

2.1 github.com/avast/retry-go

import "github.com/avast/retry-go"

func main() {
    err := retry.Do(
        func() error {
            return someOperation()
        },
        retry.Attempts(5),
        retry.Delay(time.Second),
        retry.MaxDelay(5*time.Second),
        retry.OnRetry(func(n uint, err error) {
            log.Printf("Retry #%d: %v", n, err)
        }),
    )
}

2.2 github.com/sethvargo/go-retry

import "github.com/sethvargo/go-retry"

func main() {
    ctx := context.Background()
    
    // 创建退避策略
    backoff := retry.NewFibonacci(1 * time.Second)
    backoff = retry.WithMaxDuration(10*time.Second, backoff)
    
    err := retry.Do(ctx, backoff, func(ctx context.Context) error {
        return someOperation()
    })
}

3. 自定义高级重试策略

如果需要更灵活的控制，可以自己实现：

type RetryConfig struct {
    MaxAttempts     int
    InitialDelay    time.Duration
    MaxDelay        time.Duration
    BackoffFactor   float64
    RetryIf         func(error) bool
    OnRetry         func(int, error)
}

func AdvancedRetry(config RetryConfig, fn func() error) error {
    var err error
    delay := config.InitialDelay
    
    for attempt := 1; attempt <= config.MaxAttempts; attempt++ {
        err = fn()
        if err == nil {
            return nil
        }
        
        // 检查是否需要重试
        if config.RetryIf != nil && !config.RetryIf(err) {
            return err
        }
        
        // 回调
        if config.OnRetry != nil {
            config.OnRetry(attempt, err)
        }
        
        if attempt < config.MaxAttempts {
            time.Sleep(delay)
            delay = time.Duration(float64(delay) * config.BackoffFactor)
            if delay > config.MaxDelay {
                delay = config.MaxDelay
            }
        }
    }
    return err
}

使用示例：

err := AdvancedRetry(RetryConfig{
    MaxAttempts: 5,
    InitialDelay: 100 * time.Millisecond,
    MaxDelay: 2 * time.Second,
    BackoffFactor: 1.5,
    RetryIf: func(err error) bool {
        return !errors.Is(err, ErrPermanentFailure)
    },
    OnRetry: func(attempt int, err error) {
        log.Printf("Attempt %d failed: %v", attempt, err)
    },
}, func() error {
    return someOperation()
})

4. 最佳实践建议

  1. 设置合理的重试次数：通常3-5次比较合适
  2. 使用指数退避：避免雪崩效应
  3. 区分可重试错误：不是所有错误都值得重试
  4. 添加最大延迟限制：避免等待时间过长
  5. 考虑上下文超时：避免长时间阻塞
  6. 记录重试日志：便于问题排查

通过以上方法，你可以为你的Go应用实现健壮的重试机制，提高系统的可靠性。

回到顶部