Golang自定义重试函数仅执行一次？如何实现无记录时持续退避拉取数据

你之前的重试逻辑只执行一次的核心原因有3个，和你写的retry工具函数本身的逻辑关系不大，主要是调用时的判定规则和变量作用域出了问题：

• 重试触发条件完全错位：retry函数只会在传入的闭包返回非nil错误时才会继续执行重试循环。但你拉取到空记录的场景下，闭包内既没有主动返回错误，还直接返回了nil，retry第一次执行完就会判定任务成功直接退出，根本不会进入后续的重试分支，哪怕设置100次尝试也没用。
• 闭包变量遮蔽：你在重试的匿名函数里用records, err := s.Poll(...)重新声明了局部作用域的records变量，这个变量和外层函数里的records完全隔离，哪怕闭包里拉到了有效记录，外层变量永远是空值，逻辑上也拿不到数据。
• 逻辑边界混杂：你把记录拉取、数据库落库的逻辑全塞到重试闭包中，一旦落库执行失败，没有给重试机制返回明确的错误信号，同时代码本身存在编译硬伤：Records结构体无Place字段、Messages类型和赋值逻辑不匹配，本身就无法正常运行。

1. 明确重试的判定规则 #

把「拉取记录长度为0」判定为需要触发重试的错误场景，不要把空响应当成正常执行结果返回给重试机制。

2. 修正变量作用域问题 #

闭包内不要重新声明局部变量，直接对函数外层的变量赋值，避免数据遮蔽导致的取值异常。

3. 拆分逻辑边界 #

把重试的范围限定在「拉取到非空有效记录」这个环节，拿到有效记录后再单独执行落库操作，不要把落库逻辑和拉取重试混在一起，避免职责混乱。

4. 优化退避逻辑 #

当前的指数退避会让等待时间无限翻倍，可以加上最大等待时长上限，避免后续重试时等待时间过长。

修改后的参考实现 #

// 调整后的retry函数：加上最大退避时长上限，避免无限拉长等待时间
func retry(attempts int, initSleep time.Duration, maxSleep time.Duration, f func() error) (err error) {
    for i := 0; ; i++ {
        err = f()
        // 闭包返回nil错误代表执行成功，直接退出
        if err == nil {
            return nil
        }
        // 达到最大重试次数直接退出
        if i >= (attempts - 1) {
            break
        }
        // 等待时间不超过设置的最大阈值
        currentSleep := initSleep
        if currentSleep > maxSleep {
            currentSleep = maxSleep
        }
        time.Sleep(currentSleep)
        initSleep *= 2
        log.Printf("第%d次重试，等待%v后执行，错误原因：%s", i+1, currentSleep, err)
    }
    return fmt.Errorf("已执行%d次重试，最终错误：%s", attempts, err)
}

// 修正Records结构体定义，补上缺失的字段
type Records struct {
    Messages [][]byte
    Place    uint
}

// 单条消息的反序列化结构体
type OrderMsg struct {
    Fruit  string `json:"fruit"`
    Burger string `json:"burger"`
    Fries  string `json:"fries"`
}

func (s *Service) SaveData(records Records, lastSentPlace uint) error {
    for i := lastSentPlace; i < records.Place; i++ {
        var msg OrderMsg
        // 对单条消息的字节数组做反序列化
        if err := json.Unmarshal(records.Messages[i], &msg); err != nil {
            logging.Errorf("反序列化消息失败，索引%d: %v", i, err)
            continue
        }
        order := MyStruct{
            Fruit:  msg.Fruit,
            Burger: msg.Burger,
            Fries:  msg.Fries,
        }
        if err := s.db.UpdateOrder(context.TODO(), nil, order); err != nil {
            logging.Errorf("落库失败，索引%d: %v", i, err)
            return err
        }
    }
    return nil
}

func (s *Service) MyServiceFunction(ctx context.Context, place uint, length uint) (err error) {
    lastSentPlace := place
    var records Records

    // 先执行第一次拉取
    records, err = s.Poll(context.Background(), place, length)
    if err != nil {
        logging.Infof("首次拉取失败：%v", err)
    }

    // 首次拉取拿到空记录，触发重试
    if len(records.Messages) == 0 {
        err = retry(100, 2*time.Minute, 30*time.Minute, func() error {
            // 去掉:=，直接给外层的records变量赋值，避免变量遮蔽
            records, err = s.Poll(context.Background(), place, length)
            if err != nil {
                return err
            }
            // 拉到空记录，主动返回错误，触发重试机制
            if len(records.Messages) == 0 {
                return fmt.Errorf("拉取到空记录集合")
            }
            // 拿到有效记录，返回nil，让重试机制退出
            return nil
        })
        if err != nil {
            log.Printf("重试拉取失败：%v", err)
            return err
        }
    }

    // 不管是首次拉取还是重试拉取拿到有效记录，统一执行落库
    err = s.SaveData(records, lastSentPlace)
    if err != nil {
        return err
    }
    return nil
}

调整后逻辑说明：只要拉取到空记录，闭包就会主动返回非nil错误，触发retry函数的循环逻辑，直到拉取到非空有效记录、或者达到100次重试上限才会停止，完全覆盖持续退避重试的需求。

内容的提问来源于stack exchange，提问作者newbietocoding