重试机制的实现

服务在请求资源,如果遇到网络异常等情况,导致请求失败,这时需要有个重试机制来继续请求。 常见的做法是重试3次,并随机 sleep 几秒。 业务开发的脚手架,HTTP Client 基本会封装好 retry 方法,请求失败时根据配置自动重试。下面以一个常见的 HTTP Client 为例, 看下它是如何实现请求重试。 最后整理其他一些重试机制的实现。

<!--more-->

go-resty 重试机制的实现

先看下 go-resty 在发送 HTTP 请求时, 请求重试的实现:

// Execute method performs the HTTP request with given HTTP method and URL
// for current `Request`.
// resp, err := client.R().Execute(resty.GET, "http://httpbin.org/get")
func (r *Request) Execute(method, url string) (*Response, error) {
 var addrs []*net.SRV
 var resp *Response
 var err error
 if r.isMultiPart && !(method == MethodPost || method == MethodPut || method == MethodPatch) {
 return nil, fmt.Errorf("multipart content is not allowed in HTTP verb [%v]", method)
 }
 if r.SRV != nil {
 _, addrs, err = net.LookupSRV(r.SRV.Service, "tcp", r.SRV.Domain)
 if err != nil {
 return nil, err
 }
 }
 r.Method = method
 r.URL = r.selectAddr(addrs, url, 0)
 if r.client.RetryCount == 0 {
 resp, err = r.client.execute(r)
 return resp, unwrapNoRetryErr(err)
 }
 attempt := 0
 err = Backoff(
 func() (*Response, error) {
 attempt++
 r.URL = r.selectAddr(addrs, url, attempt)
 resp, err = r.client.execute(r)
 if err != nil {
 r.client.log.Errorf("%v, Attempt %v", err, attempt)
 }
 return resp, err
 },
 Retries(r.client.RetryCount),
 WaitTime(r.client.RetryWaitTime),
 MaxWaitTime(r.client.RetryMaxWaitTime),
 RetryConditions(r.client.RetryConditions),
 )
 return resp, unwrapNoRetryErr(err)
}

重试流程

梳理 Execute(method, url) 在请求时的重试流程:

1. 如果没有设置重试次数,执行 r.client.execute(r) :直接请求 Request , 返回 Response 和 error。
2. 如果 r.client.RetryCount 不等于0 ,执行 Backoff() 函数
3. Backoff() 方法接收一个处理函数参数,根据重试策略, 进行 attempt 次网络请求, 同时接收 Retries()、WaitTime()等函数参数

Backoff函数

重点看下 Backoff() 函数做了什么动作。

Backoff()代码如下:

// Backoff retries with increasing timeout duration up until X amount of retries
// (Default is 3 attempts, Override with option Retries(n))
func Backoff(operation func() (*Response, error), options ...Option) error {
 // Defaults
 opts := Options{
 maxRetries: defaultMaxRetries,
 waitTime: defaultWaitTime,
 maxWaitTime: defaultMaxWaitTime,
 retryConditions: []RetryConditionFunc{},
 }
 for _, o := range options {
 o(&opts)
 }
 var (
 resp *Response
 err error
 )
 for attempt := 0; attempt <= opts.maxRetries; attempt++ {
 resp, err = operation()
 ctx := context.Background()
 if resp != nil && resp.Request.ctx != nil {
 ctx = resp.Request.ctx
 }
 if ctx.Err() != nil {
 return err
 }
 err1 := unwrapNoRetryErr(err) // raw error, it used for return users callback.
 needsRetry := err != nil && err == err1 // retry on a few operation errors by default
 for _, condition := range opts.retryConditions {
 needsRetry = condition(resp, err1)
 if needsRetry {
 break
 }
 }
 if !needsRetry {
 return err
 }
 waitTime, err2 := sleepDuration(resp, opts.waitTime, opts.maxWaitTime, attempt)
 if err2 != nil {
 if err == nil {
 err = err2
 }
 return err
 }
 select {
 case <-time.After(waitTime):
 case <-ctx.Done():
 return ctx.Err()
 }
 }
 return err
}

梳理 Backoff() 函数的流程:

1. Backoff() 接收 处理函数 和 可选的 Option 函数(retry optione) 作为参数
2. 默认策略3次重试, 通过 步骤一 预设的 Options, 自定义重试策略
3. 设置请求的 repsonse 和 error 变量

4. 开始进行 opts.maxRetries 次 HTTP 请求:

   1. 执行处理函数 (发起 HTTP 请求)
   2. 如果返回结果不为空并且 context 不为空,保持 repsonse 的请求上下文。 如果上下文出错, 退出 Backoff() 流程
   3. 执行 retryConditions(), 设置检查重试的条件。
   4. 根据 needsRetry 判断是否退出流程
   5. 通过 sleepDuration()计算 Duration(根据此次请求resp, 等待时间配置,最大超时时间和重试次数算出 sleepDuration。 时间算法相对复杂, 具体参考: Exponential Backoff And Jitter)
   6. 等待 waitTime 进行下个重试。 如果请求完成退出流程。

一个简单的 Demo

看具体 HTTP Client (有做过简单封装)的请求:

func getInfo() {
 request := client.DefaultClient().
 NewRestyRequest(ctx, "", client.RequestOptions{
 MaxTries: 3,
 RetryWaitTime: 500 * time.Millisecond,
 RetryConditionFunc: func(response *resty.Response) (b bool, err error) {
 if !response.IsSuccess() {
 return true, nil
 }
 return
 },
 }).SetAuthToken(args.Token)
 resp, err := request.Get(url)
 if err != nil {
 logger.Error(ctx, err)
 return 
 }
 body := resp.Body()
 if resp.StatusCode() != 200 {
 logger.Error(ctx, fmt.Sprintf("Request keycloak access token failed, messages:%s, body:%s","message", resp.Status(),string(body))),
 )
 return 
 }
 ...
}

根据以上梳理的 go-resty 的请求流程, 因为 RetryCount 大于0,所以会进行重试机制,重试次数为3。然后 request.Get(url) 进入到 Backoff() 流程,此时重试的边界条件是: !response.IsSuccess(), 直到请求成功。

一些其他重试机制的实现

可以看出其实 go-resty 的 重试策略不是很简单, 这是一个完善,可定制化, 充分考虑 HTTP 请求场景下的一个机制, 它的业务属性相对比较重。

再来看看两个常见的 Retry 实现:

实现一

// retry retries ephemeral errors from f up to an arbitrary timeout
func retry(f func() (err error, mayRetry bool)) error {
 var (
 bestErr error
 lowestErrno syscall.Errno
 start time.Time
 nextSleep time.Duration = 1 * time.Millisecond
 )
 for {
 err, mayRetry := f()
 if err == nil || !mayRetry {
 return err
 }
 if errno, ok := err.(syscall.Errno); ok && (lowestErrno == 0 || errno < lowestErrno) {
 bestErr = err
 lowestErrno = errno
 } else if bestErr == nil {
 bestErr = err
 }
 if start.IsZero() {
 start = time.Now()
 } else if d := time.Since(start) + nextSleep; d >= arbitraryTimeout {
 break
 }
 time.Sleep(nextSleep)
 nextSleep += time.Duration(rand.Int63n(int64(nextSleep)))
 }
 return bestErr
}

每次重试等待随机延长的时间, 直到 f() 执行完成 或不再重试。

实现二

func Retry(attempts int, sleep time.Duration, f func() error) (err error) {
 for i := 0; ; i++ {
 err = f()
 if err == nil {
 return
 }
 if i >= (attempts - 1) {
 break
 }
 time.Sleep(sleep)
 }
 return fmt.Errorf("after %d attempts, last error: %v", attempts, err)
}

对函数重试 attempts 次,每次等待 sleep 时间, 直到 f() 执行完成。

本文来自:Segmentfault

感谢作者:lryong

查看原文:重试机制的实现

• 编辑
• 预览