Redis事务与Lua脚本：保障数据一致性的关键技术
2025/8/30大约 7 分钟
在分布式系统中，保证数据的一致性和操作的原子性是至关重要的。Redis提供了事务机制和Lua脚本支持，帮助开发者在缓存系统中实现复杂的原子操作。本章将深入探讨Redis事务的工作原理、使用方法以及Lua脚本的强大功能，通过实际案例展示如何在生产环境中正确应用这些技术。
Redis事务机制详解
Redis事务允许将多个命令打包执行，这些命令会按顺序执行，不会被其他客户端的命令打断。但需要注意的是，Redis事务与传统关系型数据库的事务有所不同，它不支持回滚机制。
事务的基本使用
Redis事务通过MULTI、EXEC、DISCARD和WATCH四个命令来实现：
# 开启事务
MULTI
# 将命令加入事务队列
SET user:1:name "Alice"
INCR user:1:age
# 执行事务中的所有命令
EXEC事务的工作原理
- MULTI命令：开启事务，后续命令不会立即执行，而是被放入队列中
- 命令入队：客户端发送的命令会被放入事务队列，服务器返回QUEUED
- EXEC命令：执行事务队列中的所有命令，按顺序执行
- DISCARD命令：清空事务队列，放弃执行
事务的特性
- 原子性：事务中的命令会按顺序执行，不会被其他命令打断
- 隔离性：事务执行过程中，其他客户端的命令无法插入
- 无回滚：Redis事务不支持回滚，即使某个命令执行失败，其他命令仍会继续执行
使用WATCH实现乐观锁
WATCH命令用于实现乐观锁机制，它可以监视一个或多个键，如果在事务执行前这些键被其他客户端修改，则事务会执行失败：
// 使用WATCH实现乐观锁示例
@Service
public class OptimisticLockExample {
@Autowired
private RedisTemplate<String, String> redisTemplate;
public boolean transferMoney(String fromAccount, String toAccount, double amount) {
String fromBalanceKey = "account:" + fromAccount + ":balance";
String toBalanceKey = "account:" + toAccount + ":balance";
// 循环重试机制
int maxRetries = 3;
for (int i = 0; i < maxRetries; i++) {
try {
// 监视相关键
redisTemplate.watch(fromBalanceKey, toBalanceKey);
// 获取账户余额
String fromBalanceStr = redisTemplate.opsForValue().get(fromBalanceKey);
String toBalanceStr = redisTemplate.opsForValue().get(toBalanceKey);
if (fromBalanceStr == null || toBalanceStr == null) {
redisTemplate.unwatch();
return false;
}
double fromBalance = Double.parseDouble(fromBalanceStr);
double toBalance = Double.parseDouble(toBalanceStr);
// 检查余额是否充足
if (fromBalance < amount) {
redisTemplate.unwatch();
return false;
}
// 开启事务
redisTemplate.multi();
// 执行转账操作
redisTemplate.opsForValue().set(fromBalanceKey, String.valueOf(fromBalance - amount));
redisTemplate.opsForValue().set(toBalanceKey, String.valueOf(toBalance + amount));
// 执行事务
List<Object> results = redisTemplate.exec();
// 如果事务执行成功，results不为null
if (results != null) {
return true;
}
// 如果事务执行失败，results为null，继续重试
} catch (Exception e) {
redisTemplate.unwatch();
log.error("Transfer failed", e);
return false;
}
}
return false;
}
}事务的局限性
- 不支持回滚：Redis事务不支持回滚，需要开发者自行处理错误
- 运行时错误处理：如果命令在运行时出错，Redis不会回滚已执行的命令
- 语法错误检测：Redis只能在EXEC执行时检测语法错误
Lua脚本：服务端原子操作的强大工具
Lua脚本是Redis提供的另一种实现原子操作的方式，它在服务端执行，避免了网络往返开销，并且天然具有原子性。
Lua脚本的优势
- 原子性：Lua脚本在Redis中是原子执行的
- 性能优化：减少网络往返，提高执行效率
- 复杂逻辑：可以在服务端执行复杂的业务逻辑
- 减少竞争：避免多个客户端同时操作同一数据时的竞争条件
Lua脚本的基本使用
# 使用EVAL命令执行Lua脚本
EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second实际应用案例
1. 分布式锁实现
// 使用Lua脚本实现分布式锁
@Service
public class DistributedLockService {
@Autowired
private RedisTemplate<String, String> redisTemplate;
private static final String LOCK_SCRIPT =
"if redis.call('get', KEYS[1]) == ARGV[1] then " +
"return redis.call('del', KEYS[1]) " +
"else return 0 end";
private static final String ACQUIRE_SCRIPT =
"if redis.call('exists', KEYS[1]) == 0 then " +
"return redis.call('set', KEYS[1], ARGV[1], 'EX', ARGV[2]) " +
"else return 0 end";
/**
* 获取分布式锁
* @param lockKey 锁的键名
* @param lockValue 锁的值（通常为唯一标识）
* @param expireTime 过期时间（秒）
* @return 是否获取成功
*/
public boolean acquireLock(String lockKey, String lockValue, int expireTime) {
try {
Boolean result = (Boolean) redisTemplate.execute(
new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
Object result = connection.eval(
ACQUIRE_SCRIPT.getBytes(),
ReturnType.BOOLEAN,
1,
lockKey.getBytes(),
lockValue.getBytes(),
String.valueOf(expireTime).getBytes()
);
return result != null && (Long) result == 1L;
}
}
);
return result != null && result;
} catch (Exception e) {
log.error("Failed to acquire lock", e);
return false;
}
}
/**
* 释放分布式锁
* @param lockKey 锁的键名
* @param lockValue 锁的值
* @return 是否释放成功
*/
public boolean releaseLock(String lockKey, String lockValue) {
try {
Boolean result = (Boolean) redisTemplate.execute(
new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
Object result = connection.eval(
LOCK_SCRIPT.getBytes(),
ReturnType.BOOLEAN,
1,
lockKey.getBytes(),
lockValue.getBytes()
);
return result != null && (Long) result == 1L;
}
}
);
return result != null && result;
} catch (Exception e) {
log.error("Failed to release lock", e);
return false;
}
}
}2. 限流器实现
// 使用Lua脚本实现滑动窗口限流器
@Service
public class RateLimiterService {
@Autowired
private RedisTemplate<String, String> redisTemplate;
private static final String RATE_LIMIT_SCRIPT =
"local key = KEYS[1] " +
"local limit = tonumber(ARGV[1]) " +
"local window = tonumber(ARGV[2]) " +
"local current = redis.call('TIME')[1] " +
"local min = current - window " +
"redis.call('ZREMRANGEBYSCORE', key, 0, min) " +
"local current_count = redis.call('ZCARD', key) " +
"if current_count >= limit then " +
"return 0 " +
"else " +
"redis.call('ZADD', key, current, current) " +
"redis.call('EXPIRE', key, window) " +
"return 1 " +
"end";
/**
* 检查是否允许请求
* @param key 限流键
* @param limit 限制请求数
* @param window 时间窗口（秒）
* @return 是否允许请求
*/
public boolean isAllowed(String key, int limit, int window) {
try {
Boolean result = (Boolean) redisTemplate.execute(
new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
Object result = connection.eval(
RATE_LIMIT_SCRIPT.getBytes(),
ReturnType.BOOLEAN,
1,
("rate_limit:" + key).getBytes(),
String.valueOf(limit).getBytes(),
String.valueOf(window).getBytes()
);
return result != null && (Long) result == 1L;
}
}
);
return result != null && result;
} catch (Exception e) {
log.error("Failed to check rate limit", e);
return true; // 出错时允许请求通过
}
}
}3. 复杂业务逻辑处理
// 使用Lua脚本处理复杂的购物车逻辑
@Service
public class ShoppingCartService {
@Autowired
private RedisTemplate<String, String> redisTemplate;
private static final String CART_SCRIPT =
"local cartKey = KEYS[1] " +
"local productId = ARGV[1] " +
"local quantity = tonumber(ARGV[2]) " +
"local maxQuantity = tonumber(ARGV[3]) " +
"local currentQuantity = redis.call('HGET', cartKey, productId) " +
"if currentQuantity then " +
"currentQuantity = tonumber(currentQuantity) " +
"else " +
"currentQuantity = 0 " +
"end " +
"local newQuantity = currentQuantity + quantity " +
"if newQuantity <= 0 then " +
"redis.call('HDEL', cartKey, productId) " +
"return 0 " +
"elseif newQuantity > maxQuantity then " +
"return -1 " +
"else " +
"redis.call('HSET', cartKey, productId, newQuantity) " +
"return newQuantity " +
"end";
/**
* 更新购物车商品数量
* @param userId 用户ID
* @param productId 商品ID
* @param quantity 变更数量（正数为增加，负数为减少）
* @param maxQuantity 最大数量限制
* @return 更新后的数量，-1表示超出限制，0表示已删除
*/
public int updateCart(String userId, String productId, int quantity, int maxQuantity) {
try {
Long result = (Long) redisTemplate.execute(
new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
Object result = connection.eval(
CART_SCRIPT.getBytes(),
ReturnType.INTEGER,
1,
("cart:" + userId).getBytes(),
productId.getBytes(),
String.valueOf(quantity).getBytes(),
String.valueOf(maxQuantity).getBytes()
);
return result != null ? (Long) result : 0L;
}
}
);
return result != null ? result.intValue() : 0;
} catch (Exception e) {
log.error("Failed to update cart", e);
return 0;
}
}
}事务与Lua脚本的选择建议
在实际应用中，如何选择使用事务还是Lua脚本呢？
选择事务的场景
- 简单的命令组合：只需要将几个简单的命令打包执行
- 客户端逻辑复杂：需要在客户端进行复杂的逻辑判断
- 调试方便：事务更容易调试和测试
选择Lua脚本的场景
- 复杂业务逻辑：需要在服务端执行复杂的业务逻辑
- 性能要求高：希望减少网络往返开销
- 原子性要求强：需要更强的原子性保证
- 条件判断：需要根据数据状态进行条件判断
最佳实践建议
- 合理使用WATCH：在使用事务时，合理使用WATCH命令实现乐观锁
- 控制脚本复杂度：Lua脚本不宜过于复杂，避免阻塞Redis主线程
- 脚本缓存：使用SCRIPT LOAD和EVALSHA命令缓存脚本，减少网络传输
- 错误处理：在Lua脚本中做好错误处理，避免脚本执行失败影响业务
- 监控和日志：对事务和Lua脚本的执行情况进行监控和日志记录
总结
Redis的事务机制和Lua脚本为开发者提供了实现原子操作的两种重要方式：
- 事务机制：简单易用，适合简单的命令组合，但不支持回滚
- Lua脚本：功能强大，适合复杂的业务逻辑，具有更好的性能和原子性
在实际应用中，应根据具体需求选择合适的方式，并遵循最佳实践，确保系统的稳定性和性能。
通过深入理解和合理使用Redis的事务和Lua脚本，我们可以构建出更加健壮、高效的缓存系统，为业务提供更好的支持。