基于Redis 实现分布式锁

答：首先，需要在Redis服务器上设置一个全局锁，通过在服务器上设置唯一的key和value来实现，然后在需要加锁的代码中调用SETNX命令，该命令会在Redis中查找是否存在指定的key，如果key不存在，则添加key和value，并返回1，如果key存在，则不添加key和value，并返回0，从而实现分布式锁的功能。

相关问题

基于redis实现分布式锁

基于 Redis 实现分布式锁可以利用 Redis 的原子性操作和超时特性来实现。下面是一个基本的实现思路：

1. 获取锁：使用 Redis 的 SETNX 命令，如果指定的锁 key 不存在，则设置该 key 的值为当前时间戳加上锁的超时时间，并返回成功；否则，返回失败。

2. 释放锁：使用 Redis 的 EVAL 命令，通过 Lua 脚本来实现原子性的删除锁。脚本的内容是先判断锁是否存在且超时，如果是则删除锁并返回成功；否则，返回失败。

下面是一个简单的 Python 代码示例：

import redis
import time

class RedisLock:
    def __init__(self, redis_client, lock_key, expire_time):
        self.redis = redis_client
        self.lock_key = lock_key
        self.expire_time = expire_time

    def acquire(self):
        while True:
            timestamp = int(time.time() * 1000) + self.expire_time
            acquired = self.redis.set(self.lock_key, timestamp, nx=True, px=self.expire_time)
            if acquired:
                return True
            time.sleep(0.001)

    def release(self):
        lua_script = """
            if redis.call("exists", KEYS[1]) == 1 then
                local current_value = tonumber(redis.call("get", KEYS[1]))
                if current_value and current_value <= tonumber(ARGV[1]) then
                    return redis.call("del", KEYS[1])
                end
            end
            return 0
        """
        self.redis.eval(lua_script, 1, self.lock_key, int(time.time() * 1000) + self.expire_time)

# 使用示例
redis_client = redis.Redis(host='localhost', port=6379, db=0)
lock = RedisLock(redis_client, 'my_lock', 1000)  # 锁的超时时间为 1000 毫秒
if lock.acquire():
    try:
        # 执行需要加锁的代码
        pass
    finally:
        lock.release()

需要注意的是，以上代码仅是一个简单的实现示例，实际使用中还需要考虑异常处理、锁的可重入性、锁的可拥有时间等问题。

springboot 基于redis实现分布式锁示例

下面是使用 Spring Boot 基于 Redis 实现分布式锁的示例代码：

首先在 pom.xml 中添加 Redis 相关依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后创建一个 Redis 分布式锁的工具类：

@Component
public class RedisLockUtil {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 尝试获取分布式锁
     * @param key 锁的名称
     * @param value 锁的值
     * @param expireTime 锁的过期时间，单位为秒
     * @return 是否成功获取锁
     */
    public boolean tryLock(String key, String value, long expireTime) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, Duration.ofSeconds(expireTime));
        return result != null ? result : false;
    }

    /**
     * 释放分布式锁
     * @param key 锁的名称
     * @param value 锁的值
     */
    public void unlock(String key, String value) {
        String currentValue = redisTemplate.opsForValue().get(key);
        if (StringUtils.isNotBlank(currentValue) && StringUtils.equals(currentValue, value)) {
            redisTemplate.delete(key);
        }
    }
}

在上述代码中，我们使用了 RedisTemplate 对 Redis 进行操作，其中 tryLock() 方法尝试获取分布式锁，如果获取成功则返回 true，否则返回 false。unlock() 方法释放分布式锁。

最后，在需要使用分布式锁的地方注入 RedisLockUtil 并使用它进行加锁和解锁，示例如下：

@Service
public class UserService {

    @Autowired
    private RedisLockUtil redisLockUtil;

    public void updateUser(User user) {
        String lockKey = "updateUser:" + user.getId();
        String lockValue = UUID.randomUUID().toString();
        try {
            boolean lockResult = redisLockUtil.tryLock(lockKey, lockValue, 60);
            if (lockResult) {
                // 获取分布式锁成功，执行更新操作
                // ...
            } else {
                // 获取分布式锁失败，抛出异常或者重试
                // ...
            }
        } finally {
            // 释放分布式锁
            redisLockUtil.unlock(lockKey, lockValue);
        }
    }
}

在上述代码中，我们调用 RedisLockUtil 的 tryLock() 方法尝试获取分布式锁，如果获取成功则执行更新操作，否则抛出异常或者重试。最后在 finally 块中调用 RedisLockUtil 的 unlock() 方法释放分布式锁。