redis中使用事务保护数据完整性

事务是指一个执行过程，要么全部执行成功，要么失败什么都不改变。不会存在一部分成功一部分失败的情况，也就是事务的ACID四大特性（原子性、一致性、隔离性、持久性）。但是redis中的事务并不是严格意义上的事务，它只是保证了多个命令执行是按照顺序执行，在执行过程中不会插入其他的命令，并不会保证所有命令都成功。也就是说在命令执行过程中，某些命令的失败不会回滚前面已经执行成功的命令，也不会影响后面命令的执行。
redis中的事务跟pipeline很类似，但pipeline是批量提交命令到服务器，服务器执行命令过程中是一条一条执行的，在执行过程中是可以插入其他的命令。而事务是把这些命令批量提交到服务器，服务器执行命令过程也是一条一条执行的，但是在执行这一批命令时是不能插入执行其他的命令，必须等这一批命令执行完成后才能执行其他的命令。

1、事务基本结构

与数据库事务执行过程类似，redis事务是由multi、exec、discard三个关键字组成，对比数据库事务的begin、commit、rollback三个关键字。
命令行示例如下：

127.0.0.1:6379> set key1 value111
OK
127.0.0.1:6379> set key2 value222
OK
127.0.0.1:6379> mget key1 key2
1) "value111"
2) "value222"
127.0.0.1:6379> # 第一个事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value-111
QUEUED
127.0.0.1:6379(TX)> setm key2 value-222
(error) ERR unknown command `setm`, with args beginning with: `key2`, `value-222`, 
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> 
127.0.0.1:6379> mget key1 key2
1) "value111"
2) "value222"
127.0.0.1:6379> # 第二个事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value-111
QUEUED
127.0.0.1:6379(TX)> set key2 value-222
QUEUED
127.0.0.1:6379(TX)> discard
OK
127.0.0.1:6379> 
127.0.0.1:6379> mget key1 key2
1) "value111"
2) "value222"
127.0.0.1:6379> # 第三个事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value-111
QUEUED
127.0.0.1:6379(TX)> set key3 value-333 vddd
QUEUED
127.0.0.1:6379(TX)> set key2 value-222
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) (error) ERR syntax error
3) OK
127.0.0.1:6379> 
127.0.0.1:6379> mget key1 key2 key3
1) "value-111"
2) "value-222"
3) (nil)
127.0.0.1:6379>

在上面的示例过程中，第一个事务执行时输入了一个错误的命令，在提交事务时整个命令都没有执行；第二个事务提交了多个命令，但是最后回滚了事务，整个事务也不会执行；第三个事务在提交命令时，故意设置一个执行失败的命令，会发现这个失败的命令并不会影响其他命令的成功。

2、事务的执行步骤

redis中的事务是分两步执行的：第一步命令排队，也就是将所有要执行的命令添加到一个队列中，在这一步中命令不会真正执行；第二步命令执行或取消，在这一步中真正处理队列中的命令，如果是exec命令，就执行这些命令；如果是discard命令，就取消执行命令。这里需要注意，如果在排队中某些命令解析出错，即使调用了exec命令，整个队列中的命令也不会执行；但是如果在执行过程中出现了错误，它并不会影响其他命令的正常执行，一般使用封装好的客户端不会出现这种命令错误情况。

3、并发事务

多线程的项目就会有并发问题，并发问题就会存在数据不一致，数据库中解决并发问题是通过锁来实现的，在操作数据前加锁，保证数据在整个执行过程中不被其他程序修改。这种方式加锁是悲观锁，每次更新操作都认为数据会被其他程序修改，导致程序的并发性能不好；还有一种加锁方式是乐观锁，每次直到真正更新数据时才判断数据是否被更新了，如果数据被更新就放弃操作，对于读多写少的场景非常适合，一般实现乐观锁是通过版本号机制。
redis中就支持这种乐观锁机制，它的实现是通过watch命令，在开始执行事务前先通过watch监控被更新的key，如果在事务执行时发现这些key被修改了，那么就不执行事务中的命令。
下面演示的是扣费场景：在进行扣费前，先判断用户的余额，如果余额够扣，就扣减用户的账号余额；如果余额不足，就不能扣减账号余额。

watch某个key后，如果数据没有被其他客户端修改，事务将成功执行：

127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> watch user:balance:1
OK
127.0.0.1:6379> get user:balance:1
"100"
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby user:balance:1 -100
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 0
127.0.0.1:6379> get user:balance:1
"0"
127.0.0.1:6379>

watch某个key后，如果key对应的值被其他程序修改了，执行事务将不成功；如果不用watch命令，事务会成功执行。
下图展示了在两个客户端验证事务：
1、首先在下面的客户端设置键的值为100；
2、然后设置 watch 该值，并且开启事务；
3、执行减100的命令；
4、在上面的客户端中修改这个键的值，减3；
5、下面的客户端执行 exec 命令提交事务。
这几个步骤执行完成后，发现数据没有修改成功，表示 watch 命令监控到数据变动没有执行事务中的命令。

下面演示步骤与上面一样，只不过在事务前没有 watch 命令，发现数据被修改了。
watch命令只对当前客户端中的 multi / exec 之间的命令有影响，不在它们之间的命令不受影响，可以正常执行：

127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> watch user:balance:1
OK
127.0.0.1:6379> incrby user:balance:1 -3
(integer) 97
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby user:balance:1 -100
QUEUED
127.0.0.1:6379(TX)> set watchkey aaa
QUEUED
127.0.0.1:6379(TX)> exec
(nil)
127.0.0.1:6379> mget user:balance:1 watchkey
1) "97"
2) (nil)
127.0.0.1:6379>

上面这段代码在watch命令后对键的值进行了修改，发现更新成功；watch的key对应值被修改了，导致事务内的命令不执行，所以后面mget命令没有获取到新的值。

与watch对应有一个unwatch命令，它表示watch某个key后可以通过unwatch取消监控；如果watch某个key后有 exec 或 discard 命令执行，程序会自动取消监控，不必再使用unwatch取消监控：

127.0.0.1:6379> watch user:balance:1
OK
127.0.0.1:6379> unwatch
OK
127.0.0.1:6379>

4、代码中使用

使用jedis实现扣费逻辑

首先还是先使用jedis测试上面提出扣费场景：
引入依赖：

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>4.3.0</version>
</dependency>

主要代码逻辑如下：

import redis.clients.jedis.*;
import java.time.Duration;
import java.util.List;public class JedisUtil {/*** 连接池*/private JedisPool jedisPool;/*** 连接初始化* @param host* @param port* @param password*/public JedisUtil(String host, int port, String password) {JedisPoolConfig config = new JedisPoolConfig();config.setMaxTotal(256);config.setMaxIdle(256);config.setMinIdle(1);config.setMaxWait(Duration.ofMillis(300));if(password != null && !"".equals(password)) {jedisPool = new JedisPool(config, host, port, 500, password);} else {jedisPool = new JedisPool(config, host, port, 500);}}/*** 关闭连接池*/public void close() {if(jedisPool != null && !jedisPool.isClosed()) {jedisPool.clear();jedisPool.close();}}/*** 获取连接* @return*/public Jedis getJedis() {if(jedisPool != null && !jedisPool.isClosed()) {return jedisPool.getResource();}return null;}/*** 归还jedis对象* @param jedis*/public void returnJedis(Jedis jedis) {if(jedis != null) {jedis.close();}}public static void main(String[] args) {// 获取jedis连接JedisUtil util = new JedisUtil("192.168.56.101", 6379, "");// 键String key = "user:balance:1";util.deduct(key, 100);}/*** 扣减金额*/public void deduct(String key, int money) {Jedis jedis = this.getJedis();// 监控键对应值的变化jedis.watch(key);// 获取账户余额，当余额足够时扣减金额String val = jedis.get(key);if(val != null && Integer.parseInt(val) >= money) {// 开启事务Transaction multi = jedis.multi();try {// 事务中的命令multi.incrBy(key, -money);System.out.println("run in multi!");// 执行事务List<Object> exec = multi.exec();System.out.println("run exec : " + exec);} catch (Exception e) {// 放弃事务multi.discard();e.printStackTrace();} finally {this.returnJedis(jedis);}} else {// 取消监控jedis.unwatch();System.out.println("余额不足...");}}
}

在上面代码中执行事务部分添加断点，并通过其他客户端更新watch对应key的值，发现事务并不执行，这就达到了数据逻辑的一致性，不会因为其他客户端扣减金额后，该客户端继续扣减余额导致剩余金额为负数的情况。

redisTemplate使用事务

在redisTemplate中使用事务，有三种方式，下面的代码是实现上面扣费逻辑的过程：
（1）使用SessionCallback实现：

public void runTransaction(final String key, final String value) {List<Object> exec = redisTemplate.execute(new SessionCallback<List<Object>>() {@Overridepublic <K, V> List<Object> execute(RedisOperations<K, V> operations) throws DataAccessException {List<Object> exec = null;// 监控键对应值的变化operations.watch((K) key);ValueOperations<String, String> op1 = (ValueOperations<String, String>) operations.opsForValue();String val = op1.get(key);int num = Integer.parseInt(value);if(val != null && Integer.parseInt(val) >= num) {try {// 开启事务operations.multi();// 事务中的命令op1.increment(key, -num);// 执行事务exec = operations.exec();} catch (NumberFormatException e) {// 放弃事务operations.discard();e.printStackTrace();}} else {// 取消监控operations.unwatch();System.out.println("余额不足...");}return exec;}});System.out.println(exec);
}

（2）使用RedisCallback实现：

public void runTransaction(final String key, final String value) {List<Object> exec = redisTemplate.execute(new RedisCallback<List<Object>>() {@Overridepublic List<Object> doInRedis(RedisConnection connection) throws DataAccessException {List<Object> exec = null;// 监控键对应值的变化connection.watch(key.getBytes(StandardCharsets.UTF_8));byte[] val = connection.get(key.getBytes(StandardCharsets.UTF_8));int num = Integer.parseInt(value);if(val != null && Integer.parseInt(new String(val)) >= num) {try {// 开启事务connection.multi();// 事务中的命令connection.incrBy(key.getBytes(StandardCharsets.UTF_8), -num);// 执行事务exec = connection.exec();} catch (NumberFormatException e) {// 放弃事务connection.discard();e.printStackTrace();}} else {// 取消监控connection.unwatch();System.out.println("余额不足...");}return exec;}});System.out.println(exec);
}

（3）使用@Transactional注解实现：

@Transactional
public void runTransaction(final String key, final String value) {// 监控键对应值的变化redisTemplate.watch(key);String val = redisTemplate.opsForValue().get(key);int num = Integer.parseInt(value);if(val != null && Integer.parseInt(val) >= num) {// 开启事务支持// 开启这个值后，所有的命令都会在exec执行完才返回结果，所以需要返回值的命令要在这个方法前执行redisTemplate.setEnableTransactionSupport(true);try {// 开启事务redisTemplate.multi();// 事务中的命令redisTemplate.opsForValue().increment(key, -num);// 执行事务List<Object> exec = redisTemplate.exec();System.out.println(exec);} catch (Exception e) {// 放弃事务redisTemplate.discard();e.printStackTrace();} finally {// 关闭事务支持redisTemplate.setEnableTransactionSupport(false);}} else {// 取消监控redisTemplate.unwatch();System.out.println("余额不足...");}
}

事务只能保证每一条命令的原子性，并不能保证事务内所有命令的原子性，上面的示例代码已经验证了这个结论，其实redis中已经提供了一些多值指令，如：mset、mget、hmset、hmget。但是这些只能是一种数据类型的多键值对操作，这些命令是原子操作。
上面这种扣费逻辑，除了使用redis的事务支持，还可以使用lua脚本实现，lua脚本在服务端执行与事务中的命令类似，是不可分割的整体，下面演示lua脚本内容，可以实现上面一样的处理结果：
lua脚本如下：

local b = redis.call('get', KEYS[1]);
if tonumber(b) >= tonumber(ARGV[1]) thenlocal rs = redis.call('incrby', KEYS[1], 0 - tonumber(ARGV[1]));return rs;
else return nil;
end;

测试过程：

127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> get user:balance:1
"100"
127.0.0.1:6379> eval "local b = redis.call('get', KEYS[1]); if tonumber(b) >= tonumber(ARGV[1]) then local rs = redis.call('incrby', KEYS[1], 0 - tonumber(ARGV[1])); return rs; else return nil; end;" 1 user:balance:1 100
(integer) 0
127.0.0.1:6379> get user:balance:1
"0"
127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> incrby user:balance:1 -3
(integer) 97
127.0.0.1:6379> eval "local b = redis.call('get', KEYS[1]); if tonumber(b) >= tonumber(ARGV[1]) then local rs = redis.call('incrby', KEYS[1], 0 - tonumber(ARGV[1])); return rs; else return nil; end;" 1 user:balance:1 100
(nil)
127.0.0.1:6379> get user:balance:1
"97"
127.0.0.1:6379>

第一次执行余额正常够扣场景，第二次设置余额不足，会发现扣减逻辑并没有执行。
以上内容就是redis中事务的全部内容，要记住几点：
（1）redis中的事务跟我们平时用的数据库中的事务有一些差异的，它能保证多条命令执行时中间不会插入其他的命令，但并不会保证所有命令都执行成功，单条redis命令能保证原子性，但事务中的多条命令并不是原子性。
（2）redis中事务分两步完成：第一步将所有命令添加到命令队列中，这一步并不会执行命令；第二步执行队列中的命令。如果第一步中的命令有错误，第二步并不会执行；如果第二步已经开始执行了，那么部分失败的命令并不会影响其他正确命令的结果，这样就会导致一部分命令成功而另外一部分命令失败的场景。
（3）事务中不宜执行过多的命令或非常耗时的命令，因为redis底层执行命令是单线程，如果单个事务中执行过多的命令会导致其他客户端的请求被阻塞。