关于golang:重试机制的实现

服务在申请资源，如果遇到网络异样等状况，导致申请失败，这时须要有个重试机制来持续申请。常见的做法是重试 3 次，并随机 sleep 几秒。业务开发的脚手架，HTTP Client 根本会封装好 retry 办法，申请失败时依据配置主动重试。上面以一个常见的 HTTP Client 为例，看下它是如何实现申请重试。最初整顿其余一些重试机制的实现。

<!–more–>

先看下 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) 在申请时的重试流程：

如果没有设置重试次数，执行 r.client.execute(r)：间接申请 Request，返回 Response 和 error。
如果 r.client.RetryCount 不等于 0，执行 Backoff() 函数
Backoff() 办法接管一个解决函数参数，依据重试策略，进行 attempt 次网络申请，同时接管 Retries()、WaitTime() 等函数参数

重点看下 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() 函数的流程：

Backoff() 接管处理函数和可选的 Option 函数（retry optione）作为参数
默认策略 3 次重试，通过 步骤一 预设的 Options, 自定义重试策略
设置申请的 repsonse 和 error 变量
开始进行 opts.maxRetries 次 HTTP 申请：
1. 执行处理函数 (发动 HTTP 申请)
2. 如果返回后果不为空并且 context 不为空，放弃 repsonse 的申请上下文。如果上下文出错，退出 Backoff() 流程
3. 执行 retryConditions(), 设置查看重试的条件。
4. 依据 needsRetry 判断是否退出流程
5. 通过 sleepDuration() 计算 Duration（ 依据此次申请 resp, 等待时间配置，最大超时工夫和重试次数算出 sleepDuration。工夫算法绝对简单，具体参考：Exponential Backoff And Jitter）
6. 期待 waitTime 进行下个重试。如果申请实现退出流程。

看具体 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() 执行实现。

关于golang:重试机制的实现

go-resty 重试机制的实现

重试流程

Backoff 函数

一个简略的 Demo

一些其余重试机制的实现

实现一

实现二