从数据竞争到原子操作：Valkey事务与Lua脚本实战指南-优快云博客

从数据竞争到原子操作：Valkey事务与Lua脚本实战指南

【免费下载链接】valkey A new project to resume development on the formerly open-source Redis project. We're calling it Valkey, like a Valkyrie. 项目地址: https://gitcode.com/GitHub_Trending/va/valkey

你是否曾遇到过这样的情况：电商订单扣减库存时，两个请求同时读取到相同的库存数量，导致超卖？或者在转账过程中，扣款成功但收款失败，造成数据不一致？这些问题的根源在于并发操作下的数据竞争。Valkey（基于Redis的开源项目）提供了两种强大的原子操作机制——事务（MULTI/EXEC）和Lua脚本，能够有效解决这些问题。本文将深入解析这两种机制的工作原理，并通过实战案例告诉你如何正确使用它们来保障数据一致性。

读完本文，你将能够：

理解Valkey事务的ACID特性及使用限制
掌握Lua脚本在Valkey中的高级应用
区分事务与Lua脚本的适用场景
解决并发环境下的数据竞争问题

Valkey事务：基础原子操作方案

Valkey事务通过MULTI、EXEC、DISCARD和WATCH命令实现，它允许将多个命令打包，一次性按顺序执行，并且保证在事务执行期间，不会有其他客户端的命令插入到事务队列中执行。

事务的基本用法

Valkey事务的使用非常简单，主要包含以下几个步骤：

使用MULTI命令标记事务开始
输入多个命令，这些命令会被加入事务队列，但不会立即执行
使用EXEC命令执行事务队列中的所有命令，或者使用DISCARD命令放弃事务

以下是一个简单的事务示例，实现了转账功能：

# 标记事务开始
MULTI
# 从账户A扣减100元
DECRBY account:A 100
# 向账户B增加100元
INCRBY account:B 100
# 执行事务
EXEC

事务的原子性保障

Valkey事务的原子性意味着事务中的所有命令要么全部执行，要么全部不执行。这一特性通过src/multi.c中的代码实现，特别是execCommand函数。当调用EXEC时，Valkey会遍历事务队列中的所有命令并依次执行：

/* Exec all the queued commands */
unwatchAllKeys(c); /* Unwatch ASAP otherwise we'll waste CPU cycles */

server.in_exec = 1;

orig_argv = c->argv;
orig_argv_len = c->argv_len;
orig_argc = c->argc;
orig_cmd = c->cmd;
addReplyArrayLen(c, c->mstate.count);
for (j = 0; j < c->mstate.count; j++) {
    c->argc = c->mstate.commands[j].argc;
    c->argv = c->mstate.commands[j].argv;
    c->argv_len = c->mstate.commands[j].argv_len;
    c->cmd = c->realcmd = c->mstate.commands[j].cmd;

    /* 执行命令 */
    call(c, CMD_CALL_FULL);

    serverAssert(c->flag.blocked == 0);
}

乐观锁：WATCH命令的使用

Valkey事务提供了一种乐观锁机制，通过WATCH命令实现。WATCH命令可以监控一个或多个键，当事务执行前，这些键被其他客户端修改过，事务将被打断。

# 监控账户A的余额
WATCH account:A
# 获取账户A的当前余额
GET account:A
# 标记事务开始
MULTI
# 从账户A扣减100元
DECRBY account:A 100
# 向账户B增加100元
INCRBY account:B 100
# 执行事务，如果account:A被修改过，事务将失败
EXEC

WATCH命令的实现逻辑在src/multi.c中，当监控的键被修改时，相关客户端会被标记为dirty_cas状态：

/* "Touch" a key, so that if this key is being WATCHed by some client the
 * next EXEC will fail. */
void touchWatchedKey(serverDb *db, robj *key) {
    list *clients;
    listIter li;
    listNode *ln;

    if (dictSize(db->watched_keys) == 0) return;
    clients = dictFetchValue(db->watched_keys, key);
    if (!clients) return;

    /* Mark all the clients watching this key as CLIENT_DIRTY_CAS */
    listRewind(clients, &li);
    while ((ln = listNext(&li))) {
        watchedKey *wk = server_member2struct(watchedKey, node, ln);
        client *c = wk->client;
        
        c->flag.dirty_cas = 1;
        unwatchAllKeys(c);
    }
}

Lua脚本：高级原子操作方案

除了事务，Valkey还支持使用Lua脚本执行复杂的原子操作。Lua脚本在Valkey中以原子方式执行，保证脚本中的所有命令会被连续执行，不会被其他客户端的命令打断。

Lua脚本的基本用法

使用EVAL命令可以直接执行Lua脚本，语法如下：

EVAL "return redis.call('GET', KEYS[1])" 1 mykey

其中，1表示有1个键参数，mykey是传递给脚本的键参数。在脚本中，可以通过KEYS数组访问这些键，通过ARGV数组访问其他参数。

Lua脚本的原子性保障

Valkey使用单个Lua解释器执行所有脚本，并且在执行脚本期间会阻塞其他所有命令，从而保证脚本的原子性。这一机制在src/eval.c中实现：

/* Initialize the scripting environment.
 * This function is called the first time at server startup with
 * the 'setup' argument set to 1.
 * It can be called again multiple times during the lifetime of the
 * process, with 'setup' set to 0, and following a scriptingRelease() call,
 * in order to reset the Lua scripting environment. */
void scriptingInit(int setup) {
    lua_State *lua = lua_open();

    if (setup) {
        lctx.lua_client = NULL;
        server.script_disable_deny_script = 0;
        ldbInit();
    }

    /* 初始化脚本缓存和LRU列表 */
    lctx.lua_scripts = dictCreate(&shaScriptObjectDictType);
    lctx.lua_scripts_lru_list = listCreate();
    lctx.lua_scripts_mem = 0;

    luaRegisterServerAPI(lua);
    /* ... 注册其他Lua API ... */

    lctx.lua = lua;
}

脚本缓存与复用

为了提高性能，Valkey会缓存Lua脚本的SHA1哈希值，通过EVALSHA命令可以直接使用哈希值执行脚本，避免重复传输脚本内容。

# 计算脚本的SHA1哈希值
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# 返回: "a42059b356c875f0717db19a51f6a843510e767a"

# 使用哈希值执行脚本
EVALSHA a42059b356c875f0717db19a51f6a843510e767a 1 mykey

脚本缓存的实现逻辑在src/eval.c中，使用LRU策略管理缓存的脚本：

/* Users who abuse EVAL will generate a new lua script on each call, which can
 * consume large amounts of memory over time. Since EVAL is mostly the one that
 * abuses the lua cache, and these won't have pipeline issues (scripts won't
 * disappear when EVALSHA needs it and cause failure), we implement script eviction
 * only for these (not for one loaded with SCRIPT LOAD). */
#define LRU_LIST_LENGTH 500
listNode *luaScriptsLRUAdd(client *c, sds sha, int evalsha) {
    /* Script eviction only applies to EVAL, not SCRIPT LOAD. */
    if (evalsha) return NULL;

    /* Evict oldest. */
    while (listLength(lctx.lua_scripts_lru_list) >= LRU_LIST_LENGTH) {
        listNode *ln = listFirst(lctx.lua_scripts_lru_list);
        sds oldest = listNodeValue(ln);
        luaDeleteFunction(c, oldest);
        server.stat_evictedscripts++;
    }

    /* Add current. */
    listAddNodeTail(lctx.lua_scripts_lru_list, sha);
    return listLast(lctx.lua_scripts_lru_list);
}

事务 vs Lua脚本：如何选择？

Valkey的事务和Lua脚本都能提供原子操作，但它们各有优缺点，适用于不同场景。

功能对比

特性	事务	Lua脚本
命令数量	多个命令	一个脚本（可包含多个命令）
条件执行	有限（依赖WATCH）	完全支持（Lua条件语句）
错误处理	简单（要么全部执行，要么全部不执行）	灵活（可捕获和处理错误）
网络开销	多个命令，多次网络往返	一次网络往返
学习成本	低	中（需要了解Lua语言）

适用场景分析

简单的多命令原子操作：使用事务更简单直观
复杂的条件逻辑：Lua脚本提供更强大的表达能力
网络带宽受限：Lua脚本可以减少网络往返
需要复用的逻辑：Lua脚本可以缓存，提高性能

实战案例：库存扣减系统

假设我们需要实现一个电商库存扣减系统，要求：

检查库存是否充足
扣减库存
记录订单
所有操作需要原子性执行

使用Lua脚本实现如下：

-- 库存扣减脚本，参数：商品ID，订单ID，购买数量
local product_id = KEYS[1]
local order_id = KEYS[2]
local quantity = tonumber(ARGV[1])

-- 检查库存
local stock = redis.call('GET', 'stock:' .. product_id)
if not stock or tonumber(stock) < quantity then
    return 0  -- 库存不足
end

-- 扣减库存
redis.call('DECRBY', 'stock:' .. product_id, quantity)

-- 记录订单
redis.call('HSET', 'order:' .. order_id, 'product_id', product_id, 'quantity', quantity, 'status', 'pending')

return 1  -- 成功

执行脚本：

EVAL "local product_id = KEYS[1] local order_id = KEYS[2] local quantity = tonumber(ARGV[1]) local stock = redis.call('GET', 'stock:' .. product_id) if not stock or tonumber(stock) < quantity then return 0 end redis.call('DECRBY', 'stock:' .. product_id, quantity) redis.call('HSET', 'order:' .. order_id, 'product_id', product_id, 'quantity', quantity, 'status', 'pending') return 1" 2 product:1001 order:20230501001 2

这个Lua脚本实现了一个完整的库存扣减逻辑，并且保证了原子性。相比使用事务，Lua脚本更简洁，并且减少了网络往返次数。

最佳实践与常见陷阱

事务使用注意事项

WATCH命令的时机：必须在MULTI命令之前执行WATCH
事务中的错误处理：事务中某个命令执行失败，不会影响其他命令的执行
不要在事务中使用阻塞命令：如BLPOP，会导致事务一直阻塞

Lua脚本使用注意事项

避免长时间运行的脚本：会阻塞Valkey服务器
使用KEYS数组传递键：不要在脚本中硬编码键名，便于集群环境使用
控制脚本输出大小：避免返回过大的数据
错误处理：使用pcall捕获命令执行错误

-- 带错误处理的Lua脚本示例
local status, result = pcall(redis.call, 'GET', KEYS[1])
if not status then
    return 'ERROR: ' .. result
end
return result

性能优化建议

复用Lua脚本：使用SCRIPT LOAD和EVALSHA减少网络传输
合理设置事务大小：过大的事务会增加内存消耗和执行时间
监控脚本执行时间：通过SLOWLOG监控慢脚本
避免在脚本中使用循环：特别是无限循环或大数据量循环

总结与展望

Valkey的事务和Lua脚本为我们提供了强大的原子操作能力，有效解决了并发环境下的数据竞争问题。事务适用于简单的多命令原子操作，而Lua脚本则更适合实现复杂的业务逻辑。

随着Valkey项目的不断发展，我们可以期待更多原子操作相关的功能优化。例如，未来可能会引入更多Lua API，或者增强事务的错误处理能力。

掌握Valkey的原子操作机制，将帮助你构建更可靠、更高性能的分布式系统。无论是简单的计数器，还是复杂的业务逻辑，都可以通过事务或Lua脚本来保证数据的一致性。

希望本文能够帮助你更好地理解和使用Valkey的原子操作特性。如果你有任何问题或建议，欢迎通过项目贡献指南参与到Valkey社区中来。

扩展学习资源

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考