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>>() {
        @Override
        public <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>>() {
        @Override
        public 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]) then
  local 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底层执行命令是单线程，如果单个事务中执行过多的命令会导致其他客户端的请求被阻塞。