基于Go语言为GridDB事务操作实现自定义重试逻辑

1. 实现带抖动的指数退避重试逻辑 #

指数退避能随重试次数增加延长等待时间，而抖动通过加入随机值避免多个客户端同时重试引发的"惊群效应"。以下是改造后的核心重试循环：

package main

import (
    "fmt"
    "math/rand"
    "github.com/griddb/go-client/gs"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子

    gridstore, err := connectToGridDB()
    if err != nil {
        fmt.Printf("Failed to connect to GridDB: %v\n", err)
        return
    }
    defer gridstore.Close()

    retryLimit := 5
    baseBackoff := 1 * time.Second

    for attempt := 0; attempt < retryLimit; attempt++ {
        err := executeTransactionalOperation(gridstore)
        if err == nil {
            fmt.Println("Transaction succeeded.")
            break
        }

        if !isRetryableError(err) {
            fmt.Printf("Non-retryable error occurred: %v\n", err)
            return
        }

        fmt.Printf("Retryable failure on attempt %d: %v\n", attempt+1, err)
        // 计算指数退避时间并添加抖动
        backoff := baseBackoff * (1 << attempt)
        jitter := time.Duration(rand.Int63n(int64(backoff)))
        totalBackoff := backoff + jitter
        fmt.Printf("Waiting %v before next retry...\n", totalBackoff)
        time.Sleep(totalBackoff)

        if attempt == retryLimit-1 {
            fmt.Printf("All %d retry attempts exhausted: %v\n", retryLimit, err)
            // 处理最终失败（如告警、持久化错误日志等）
        }
    }
}

2. 区分可重试与不可重试错误 #

GridDB返回的错误可分为临时故障（可重试）和永久错误（需立即终止），通过错误码精准判断：

func isRetryableError(err error) bool {
    gsErr, ok := err.(gs.Error)
    if !ok {
        // 非GridDB原生错误，根据业务场景判断（如I/O错误可重试，参数错误不可）
        return false
    }

    switch gsErr.Code() {
    // 临时故障类型：锁冲突、网络问题、节点不可用、事务超时
    case gs.ErrorCode_CONTAINER_LOCK_CONFLICT,
         gs.ErrorCode_NETWORK_ERROR,
         gs.ErrorCode_CONNECTION_LOSS,
         gs.ErrorCode_TRANSACTION_TIMEOUT,
         gs.ErrorCode_NODE_NOT_AVAILABLE:
        return true
    // 永久错误类型：权限不足、容器不存在、数据格式错误、主键冲突
    case gs.ErrorCode_PERMISSION_DENIED,
         gs.ErrorCode_CONTAINER_NOT_FOUND,
         gs.ErrorCode_INCONSISTENT_TYPE,
         gs.ErrorCode_DUPLICATE_KEY:
        return false
    default:
        // 未知错误默认不重试，避免无限循环
        return false
    }
}

3. 与GridDB事务管理特性无缝集成的建议 #

3.1 每次重试启动全新事务 #

GridDB事务对象不可复用，每次重试必须创建新事务实例，避免旧事务状态异常导致的问题：

func executeTransactionalOperation(gridstore *gs.GridStore) error {
    // 启动新的读写事务
    tx, err := gridstore.StartTransaction(gs.TX_READ_WRITE)
    if err != nil {
        return err
    }
    // 确保未提交的事务最终回滚
    defer func() {
        if tx != nil {
            tx.Rollback()
        }
    }()

    // 必须通过事务对象获取容器引用，而非直接从GridStore获取
    container, err := tx.GetContainer("my_container")
    if err != nil {
        return err
    }

    // 执行事务操作（示例：插入数据）
    row := gs.CreateRow([]gs.Type{gs.Type_STRING, gs.Type_INT})
    row.SetString(0, "user_123")
    row.SetInt(1, 2024)
    if err := container.Put(row); err != nil {
        return err
    }

    // 提交事务后清空指针，避免defer执行回滚
    if err := tx.Commit(); err != nil {
        return err
    }
    tx = nil
    return nil
}

3.2 保证操作幂等性 #

重试可能导致事务重复执行，需确保业务操作是幂等的（如使用唯一主键、幂等性接口），避免数据重复或不一致。

3.3 合理设置事务超时 #

通过事务选项设置超时时间，防止长事务占用锁资源：

// 示例：设置事务超时为10秒
txOptions := gs.NewTransactionOptions()
txOptions.SetTimeout(10 * time.Second)
tx, err := gridstore.StartTransactionWithOptions(gs.TX_READ_WRITE, txOptions)

3.4 禁止嵌套事务 #

GridDB不支持嵌套事务，确保每个重试流程中仅启动一个顶层事务。

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