Redis实现分布式锁

Why

为什么要使用分布式锁

当多个节点并发访问共享资源时，可能会引发资源竞争问题（比如秒杀商品超卖，重复扣库存等），使用分布式锁可以保证同一时刻只有一个节点可以操着共享资源，保证数据一致性。

为什么要用Redis实现分布式锁

1. 高性能，低延迟。redis直接对内存操着，读写性能高
2. 高可用性。Redis 的主从同步和集群模式，分布式锁可以在系统发生故障时仍然保持高可用性
3. 在分布式环境下，不同服务通常部署在不同的机器或容器中，使用本地锁无法保证全局唯一性

How

pom.xml文件导入依赖

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

配置redis

spring:
  redis:
    host: 127.0.0.1
    port: 6379

实现工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.List;

@Component
public class RedisLockUtil {


    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //默认前缀
    private final String DEFAULT_PREFIX = "lock:";

    /**
     * 加锁
     *
     * @param key        键
     * @param value      值
     * @param expireTime 锁过期时间
     * @return 加锁是否成功
     */
    private boolean lock(String key, String value, long expireTime) {
        String luaScript = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then return redis.call('expire', KEYS[1], ARGV[2]) else return 0 end";

        List<String> keys = Collections.singletonList(key);
        RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long res = stringRedisTemplate.execute(redisScript, keys, value, String.valueOf(expireTime));

        return Long.valueOf(1).equals(res);
    }

    /**
     * 尝试加锁
     *
     * @param key            键
     * @param value          值
     * @param timeout        加锁等待最大时间(s)，超时返回false
     * @param expirationTime 锁过期时间(s)
     * @return 加锁是否成功
     */
    public boolean tryLock(String key, String value, long timeout, long expirationTime) {
        long now = System.currentTimeMillis();

        do {
            if (lock(DEFAULT_PREFIX + key, value, expirationTime)) {
                return true;
            } else {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        } while (System.currentTimeMillis() < now + timeout*1000);

        return false;
    }

    /**
     * 释放锁
     *
     * @param key   键
     * @param value 值
     * @return 释放锁是否成功
     */
    public boolean delLock(String key, String value) {
        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        List<String> keys = Collections.singletonList(DEFAULT_PREFIX + key);
        RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long res = stringRedisTemplate.execute(redisScript, keys, value);

        return Long.valueOf(1).equals(res);
    }
}

说明

使用lua脚本进行加锁、释放锁

为什么这样做呢，以加锁操着为例，先setnx，如果成功设置过期时间。那么，如果setnx后，服务挂掉了，那么刚才设置的锁将是无过期时间，这样显然是不可以的。

思考

那么现在又有一个问题，如果服务还没有结束，锁先过期了，应该怎么办？

看了好多博客，说加锁时给他设置一个watchDog，定时修改锁的过期时间，但是这样的话，设置过期时间的意义是什么！！不懂

What

分布式锁主要用于在分布式系统中解决资源竞争问题，确保多个节点或线程在访问共享资源时具有一致性和互斥性。