基于Redis实现乐观锁

乐观锁概念

所谓的乐观锁，其实也就是CAS的机制，CAS的本质是Compare And Swap, 就是需要知道一个key在修改前的值进行比较，如果我要修改发现当前值和我之前获取的值不同，那么就不会更改。

Redis实现乐观锁

在Redis中，我们可以依赖WATCH这个命令。这个命令一旦运行，他会确保只有在WATCH监视的键在调用EXEC之前没有改变时，后续的事务才会执行。

WATCH COUNTER
GET COUNTER
MULTI
SET COUNTER <从GET中获取的值 ，改变的值>
EXEC

• WATCH: 使用WATCH命令监视一个或多个键。这个命令会监视给定键直到事务开始 (即执行MULTI)
• GET： 在事务开启之前获得之前的值
• MULTI: 使用MULTI命令开启事务
• SET：在事务中执行修改命令
• EXEC: 使用EXEC执行事务。如果从事务开始以来监视的键被修改过，EXEC 会 返回nail, 这表示事务中的命令没有被执行。

使用Redission实现代码：和上述流程类似：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonOptimisticLockExample {
    private final RedissonClient redissonClient;

    public RedissonOptimisticLockExample() {
        // 初始化RedissonClient
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        this.redissonClient = Redisson.create(config);
    }

    public void updateValue(String key, String newValue) {
        RLock lock = redissonClient.getLock(key);
        try {
            // 使用WATCH监控key的旧值
            String oldValue = redissonClient.getAtomicLong(key).toString();
            redissonClient.watch(key);

            // 尝试获取锁
            if (lock.tryLock()) {
                try {
                    // 再次检查旧值是否一致，如果不一致表示有其他线程已更新
                    String current = redissonClient.getAtomicLong(key).toString();
                    if (current.equals(oldValue)) {
                        // 如果一致，执行更新
                        redissonClient.getAtomicLong(key).set(Long.parseLong(newValue));
                        System.out.println("Value updated to " + newValue);
                    } else {
                        System.out.println("Value has been updated by another thread.");
                    }
                } finally {
                    // 执行事务，如果检测到旧值变化则取消事务
                    redissonClient.executeInMultiTx(() -> {
                        if (!current.equals(oldValue)) {
                            throw new RuntimeException("Transaction cancelled due to value change.");
                        }
                        // 执行其他事务操作...
                        return "SUCCESS";
                    });
                    lock.unlock();
                }
            } else {
                System.out.println("Failed to acquire the lock.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        RedissonOptimisticLockExample example = new RedissonOptimisticLockExample();
        // 假设我们要更新的键和新值
        String key = "myCounter";
        String newValue = "10"
        // 调用更新方法
        example.updateValue(key, newValue);
    }
}