如何正确使用redis分布式锁

本是古典何须时尚 2023-03-13 13:10 9阅读 0赞

# 什么是分布式锁 #

分布式锁可以理解为：控制分布式系统有序的去对共享资源进行操作，通过互斥来保持一致性。

# 实现原理 #

*  ## 互斥性 ##
 *  ## 安全性 ##
 *  ## 避免死锁 ##
 *  ## 保证加锁和解锁操作是原子性操作 ##

# 使用redis实现分布式锁 #

java代码如下：

import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.stereotype.Component;
    
    import java.time.Duration;
    import java.util.Arrays;
    import java.util.UUID;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    
    /**
     * @author myvina@qq.com
     * @date 2020/5/13  21:40
     * @usage
     */
    
    @Component
    public class RedisLock implements Lock {
        private static final String KEY = "REDIS_LOCK_KEY";
        private static final Duration TIMEOUT = Duration.ofMillis(5000);
        private static final String UNLOCK_LUA_SCRIPT =
                "if redis.call(\"get\", KEYS[1]) == ARGV[1] then\n" +
                "    return redis.call(\"del\", KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";
        private ThreadLocal<String> uniqueKey = new ThreadLocal<>();
        private final RedisTemplate redisTemplate;
        private final ValueOperations<String, String> lockOperation;
        private final DefaultRedisScript<Long> unlockLuaScript;
    
        public RedisLock(RedisTemplate redisTemplate) {
            this.redisTemplate = redisTemplate;
            lockOperation = redisTemplate.opsForValue();
            unlockLuaScript = new DefaultRedisScript<>(UNLOCK_LUA_SCRIPT, Long.class);
        }
    
        public void lock(String value) {
            for(; ;) {
                if (lockOperation.setIfAbsent(KEY, value, TIMEOUT)) {
                    uniqueKey.set(value);
                    return;
                }
            }
        }
    
        /**
         * 自旋锁
         */
        @Override
        public void lock() {
            for(; ;) {
                if (tryLock()) {
                    return;
                }
            }
        }
    
        @Override
        public void lockInterruptibly() throws InterruptedException {
    
        }
    
        @Override
        public boolean tryLock() {
            // TODO 使用雪花算法生成分布式唯一id
            String uuid = UUID.randomUUID().toString();
            if (lockOperation.setIfAbsent(KEY, uuid, TIMEOUT)) {
                uniqueKey.set(uuid);
                return true;
            }
            return false;
        }
    
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            return false;
        }
    
        @Override
        public void unlock() {
            redisTemplate.execute(unlockLuaScript, Arrays.asList(KEY), uniqueKey.get());
            uniqueKey.remove();
        }
    
        @Override
        public Condition newCondition() {
            return null;
        }
    }

# 会出现的问题 #

在redis server是单机的情况下，该代码不会出现问题；但是当redis是集群部署的时候，redis主从节点的数据同步是异步的，如果redis的master节点在锁未同步到slave节点的时候宕机了？会出现什么情况，举个例子。

1、进程A在master节点获得了锁。

2、在锁同步到slave之前，master宕机，数据还没有同步到slave。

3、slave变成了新的master节点。

4、进程B也得到了和进程A相同的锁

**因此，如果业务上使用该锁，应该允许在master宕机期间，多个客户端同时持有锁。**