在Golang开发过程中，我们经常会遇到一些临时性的错误，比如网络波动导致的请求失败、数据库连接短暂不可用等情况。这类错误通常不需要直接终止程序，通过重试操作往往就能恢复正常执行。结合循环和条件判断实现重试机制，是Golang中处理这类问题的常用方案，我们可以根据错误类型、重试次数、重试间隔等条件灵活控制重试逻辑。
基础重试机制实现
最基础的重试机制可以通过for循环配合重试次数计数器实现，当操作执行失败时，判断当前重试次数是否小于最大重试次数，如果是则继续重试，否则返回最终错误。
下面是一个简单的示例，模拟一个可能失败的操作，最多重试3次：
package main
import (
"errors"
"fmt"
"time"
)
// 模拟可能失败的操作，随机返回错误
func mockOperation() error {
// 模拟30%的失败概率
if time.Now().Unix()%3 == 0 {
return errors.New("临时操作失败")
}
return nil
}
// 基础重试函数，最多重试maxRetries次
func baseRetry(maxRetries int) error {
var err error
for i := 0; i < maxRetries; i++ {
fmt.Printf("第%d次尝试执行操作n", i+1)
err = mockOperation()
// 条件判断：如果操作成功，直接返回nil
if err == nil {
fmt.Println("操作执行成功")
return nil
}
// 如果还有重试次数，等待1秒后继续
if i < maxRetries-1 {
time.Sleep(1 * time.Second)
}
}
// 重试次数耗尽，返回最终错误
return fmt.Errorf("重试%d次后仍然失败: %v", maxRetries, err)
}
func main() {
err := baseRetry(3)
if err != nil {
fmt.Println("最终错误:", err)
}
}
带错误类型过滤的重试机制
实际场景中，并不是所有错误都值得重试，比如参数错误、权限错误这类永久性错误，重试多少次都无法解决。我们可以结合条件判断，只对特定的临时性错误进行重试。
下面的示例实现了错误类型过滤，只有遇到临时错误时才触发重试：
package main
import (
"errors"
"fmt"
"time"
)
// 定义临时错误类型
var ErrTemporary = errors.New("临时错误")
// 模拟返回不同类型的错误
func mockOperationWithErrType() error {
// 模拟返回临时错误
if time.Now().Unix()%2 == 0 {
return ErrTemporary
}
// 模拟返回永久性错误
return errors.New("参数错误，不可重试")
}
// 带错误类型过滤的重试函数
func retryWithErrFilter(maxRetries int) error {
var err error
for i := 0; i < maxRetries; i++ {
fmt.Printf("第%d次尝试执行操作n", i+1)
err = mockOperationWithErrType()
if err == nil {
fmt.Println("操作执行成功")
return nil
}
// 条件判断：如果是临时错误才重试，否则直接返回错误
if !errors.Is(err, ErrTemporary) {
fmt.Println("遇到不可重试的错误，终止重试")
return err
}
// 临时错误则等待后重试
if i < maxRetries-1 {
time.Sleep(1 * time.Second)
}
}
return fmt.Errorf("重试%d次后仍然失败: %v", maxRetries, err)
}
func main() {
err := retryWithErrFilter(3)
if err != nil {
fmt.Println("最终错误:", err)
}
}
优化重试机制：指数退避策略
基础的重试机制使用固定的重试间隔，在高并发场景下可能会导致大量请求同时重试，加重服务压力。我们可以结合条件判断实现指数退避策略，每次重试的间隔时间按指数增长，减少服务压力。
下面的示例实现了带指数退避的重试机制：
package main
import (
"errors"
"fmt"
"math"
"time"
)
// 模拟可能失败的操作
func mockOperation() error {
if time.Now().Unix()%3 == 0 {
return errors.New("临时操作失败")
}
return nil
}
// 带指数退避的重试函数
// maxRetries: 最大重试次数
// baseDelay: 基础延迟时间（毫秒）
func retryWithBackoff(maxRetries int, baseDelay time.Duration) error {
var err error
for i := 0; i < maxRetries; i++ {
fmt.Printf("第%d次尝试执行操作n", i+1)
err = mockOperation()
if err == nil {
fmt.Println("操作执行成功")
return nil
}
// 如果还有重试次数，计算指数退避的延迟时间
if i < maxRetries-1 {
// 延迟时间 = 基础延迟 * 2^重试次数，最大不超过10秒
delay := baseDelay * time.Duration(math.Pow(2, float64(i)))
if delay > 10*time.Second {
delay = 10 * time.Second
}
fmt.Printf("等待%d毫秒后重试n", delay.Milliseconds())
time.Sleep(delay)
}
}
return fmt.Errorf("重试%d次后仍然失败: %v", maxRetries, err)
}
func main() {
// 基础延迟设置为500毫秒
err := retryWithBackoff(4, 500*time.Millisecond)
if err != nil {
fmt.Println("最终错误:", err)
}
}
通用重试工具函数封装
为了在不同场景中复用重试逻辑，我们可以封装一个通用的重试工具函数，支持自定义重试次数、重试间隔、错误判断条件等参数。
下面是通用重试函数的实现：
package main
import (
"errors"
"fmt"
"time"
)
// 定义重试函数的类型，操作函数返回错误
type Operation func() error
// 通用重试函数
// op: 要执行的操作函数
// maxRetries: 最大重试次数
// shouldRetry: 判断错误是否需要重试的函数，返回true表示需要重试
// delay: 每次重试的固定延迟时间
func Retry(op Operation, maxRetries int, shouldRetry func(err error) bool, delay time.Duration) error {
var err error
for i := 0; i < maxRetries; i++ {
err = op()
if err == nil {
return nil
}
// 条件判断：如果不需要重试，直接返回错误
if !shouldRetry(err) {
return err
}
// 还有重试次数则等待后重试
if i < maxRetries-1 {
time.Sleep(delay)
}
}
return fmt.Errorf("重试%d次后失败: %v", maxRetries, err)
}
// 模拟操作1：网络请求
func networkRequest() error {
// 模拟网络临时错误
return errors.New("网络连接超时")
}
// 模拟操作2：数据库查询
func dbQuery() error {
return nil
}
func main() {
// 场景1：重试网络请求，最多3次，所有错误都重试，每次间隔1秒
err := Retry(networkRequest, 3, func(err error) bool {
return true
}, 1*time.Second)
if err != nil {
fmt.Println("网络请求最终失败:", err)
}
// 场景2：重试数据库查询，最多2次，只重试临时错误，每次间隔500毫秒
tempErr := errors.New("数据库临时不可用")
err = Retry(dbQuery, 2, func(err error) bool {
return errors.Is(err, tempErr)
}, 500*time.Millisecond)
if err != nil {
fmt.Println("数据库查询最终失败:", err)
}
}
注意事项
- 重试次数不宜设置过大，避免程序长时间阻塞，通常3到5次即可满足大部分场景需求。
- 重试间隔需要根据操作类型调整，网络请求可以适当增加间隔，本地操作可以缩短间隔。
- 一定要对错误类型进行判断，避免对永久性错误进行无效重试。
- 如果操作本身有副作用，比如已经修改了部分数据，重试前需要确认是否支持幂等性，避免重复操作带来数据问题。