Redis乐观锁事务失败排查：HSET场景下TxFailedErr问题

问题描述 #

测试Redis乐观锁的HSET实现时，高并发更新同一key场景下偶尔收到Redis客户端抛出的TxFailedErr(redis: transaction failed)错误，不符合预期。VM内存充足，想搞清楚：

1. 问题根源是什么？
2. 怎么查看事务失败的具体原因？

原代码 #

func hset(ctx context.Context, c *client, key, field string, object Revisioner) (newObj Revisioner, err error) {

    txf := func(tx *redis.Tx) error {
        // Get the current value or some state of the key
        current, err := tx.HGet(ctx, key, field).Result()
        if err != nil && err != redis.Nil {
            return fmt.Errorf("hget: %w", err)
        }
        // Compare revisions for optimistic locking
        ok, err := object.RevisionCompare([]byte(current))
        if err != nil {
            return fmt.Errorf("revision compare: %w", err)
        }
        if !ok {
            return ErrModified
        }

        // Create a new object with a new revision
        newObj = object.WitNewRev()

        data, err := json.Marshal(newObj)
        if err != nil {
            return fmt.Errorf("marshalling: %w", err)
        }

        // Execute the HSET command within the transaction
        _, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
            pipe.HSet(ctx, key, field, string(data))
            return nil
        })
        return err
    }

    // Execute the transaction with the Watch method
    err = c.rc.Watch(ctx, txf, key)
    if err == redis.TxFailedErr {
        return nil, fmt.Errorf("transaction error: %w", err)
    } else if err != nil {
        return nil, ErrModified
    }

    return newObj, nil
}

问题根源 #

1. Watch监听的是整个Hash Key，不是单个Field #

你用Watch监听的是整个Hash类型的key，但实际只更新其中一个field。Redis的Watch机制是监听整个key的变更——只要这个Hash里的任意其他field被并发修改，Watch就会触发事务终止，抛出TxFailedErr。这就是高并发下偶尔出错的核心原因。

2. 事务内冗余嵌套TxPipelined #

在事务回调里已经处于Tx上下文了，直接调用tx.HSet就行，没必要再套一层TxPipelined。这种写法不仅多余，还可能引入不必要的逻辑复杂度，甚至触发内部异常。

3. 错误处理逻辑混乱 #

Watch返回错误时，你把非TxFailedErr的错误直接返回ErrModified，这会把网络错误、序列化错误等真实问题掩盖掉，导致你没法准确排查问题。

如何查看事务失败的具体原因 #

TxFailedErr本身只告诉你事务因为Watch的key被修改而终止，没有更多细节，但可以通过这几种方式排查：

• 加日志埋点：在txf的关键步骤（比如HGet后、版本对比后、HSet前）打日志，记录key、field、当前版本、新版本等信息，事务失败时通过日志回溯是否有其他请求改了这个key的其他field。
• 针对性测试：临时只模拟同一field的并发更新，看还会不会出TxFailedErr——如果不再出现，就实锤是其他field变更导致的问题。
• 用Redis MONITOR命令：测试环境跑redis-cli MONITOR，实时看所有Redis命令，事务失败时查同一时间窗口内这个key的其他修改操作。

修复方案 #

优化原代码（针对整个Hash的Watch场景） #

先把冗余的TxPipelined去掉，修正错误处理逻辑：

func hset(ctx context.Context, c *client, key, field string, object Revisioner) (newObj Revisioner, err error) {
    txf := func(tx *redis.Tx) error {
        // 获取指定field的当前值
        current, err := tx.HGet(ctx, key, field).Result()
        if err != nil && err != redis.Nil {
            return fmt.Errorf("hget failed: %w", err)
        }
        // 版本对比做乐观锁校验
        ok, err := object.RevisionCompare([]byte(current))
        if err != nil {
            return fmt.Errorf("revision compare failed: %w", err)
        }
        if !ok {
            return ErrModified
        }

        // 生成带新版本的对象
        newObj = object.WitNewRev()

        data, err := json.Marshal(newObj)
        if err != nil {
            return fmt.Errorf("json marshal failed: %w", err)
        }

        // 直接在事务内执行HSet，无需嵌套TxPipelined
        _, err = tx.HSet(ctx, key, field, string(data)).Result()
        return err
    }

    // 执行带Watch的事务
    err = c.rc.Watch(ctx, txf, key)
    if err != nil {
        if err == redis.TxFailedErr {
            // 事务因并发修改终止，可根据业务决定是否重试
            return nil, fmt.Errorf("transaction aborted by concurrent modification: %w", err)
        }
        // 区分其他错误，不直接返回ErrModified
        return nil, fmt.Errorf("transaction execution failed: %w", err)
    }

    return newObj, nil
}

实现Field级精准乐观锁（可选） #

如果希望只监听单个field的变更（而非整个Hash），Redis本身不支持Watch单个field，但可以这么搞：

• 拆分key：把每个field单独存成一个独立的key，比如key:field，这样Watch就能精准监听单个field的变更。
• 用Lua脚本：把版本校验、更新逻辑写到Lua脚本里，利用Lua脚本的原子性实现乐观锁，避免Watch的局限性。

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