Redis Study 分布式锁

原理

分布式锁 : 满足分布式系统或集群模式下多进程可以并且互斥的锁

1. 多进程可见
2. 互斥
3. 高可用
4. 高性能
5. 安全性
6. 功能性

分布式锁的实现 基于redis

基于redis实现分布式锁

public class SimpleRedisLock implements ILock{

    private String name;
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";

    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取线程标示
        long threadId = Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        // 释放锁
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

要注意的是：我们在调用锁的时候，锁的是用户id，而不是所有用户，防止的是某个id多并发下单

redis分布式锁误删

** 对于上诉的方法，由于对锁释放时没有判断是否释放的是自己线程的锁，所以会出现以下情况 **

如图：
线程1由于业务的阻塞，没有处理，但是由于超时，锁已经释放了，此时线程2进入，显然可以拿到锁，但是线程1的业务此次完成，要触发解锁的过程，此时解锁就解的是线程2的锁，此时线程3进入，显然可以拿到锁，可以看到线程2和线程3都拿到了锁，发生线程冲突的问题

解决方式也很简单，只需在释放锁时判断是否为当前线程的锁即可，如下图


由于在集群的模式下，我们有多个jvm，在不同的jvm下创建的线程id是可能重复的，所以使用uuid+线程id

public class SimpleRedisLock implements ILock{

    private String name;
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";

    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取线程标示
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        // 获取线程标示
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁中的标示
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        // 判断标示是否一致
        if(threadId.equals(id)) {
            // 释放锁
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }
}

分布式锁的原子性问题

由于jvm的垃圾回收机制，在线程1判断完成后，出现堵塞时会出现如上图的情况，导致再次出现多线程执行的问题，这是由于判断和释放虽然是紧接着之后的，但不是原子性操作

解决方法：将两个操作实现为原子性

基于Lua脚本实现分布式锁的释放逻辑实现原子性操作

由于redis的事务只可以保证原子性，无法保证一致性，所以使用Lua脚本实现

--  Lua脚本
-- 比较线程标示与锁中的标示是否一致
if(redis.call('get', KEYS[1]) ==  ARGV[1]) then
    -- 释放锁 del key
    return redis.call('del', KEYS[1])
end
return 0

    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }


	public void unlock() {
        // 调用lua脚本
        stringRedisTemplate.execute(
                UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + name),
                ID_PREFIX + Thread.currentThread().getId());
    }

上述就是使用Lua脚本实现释放锁的过程，由于是使用脚本实现，所以执行是原子性的

** 基于redis的分布式锁，可以redisson组件 **

redis分布式锁的缺点

基于以上缺点，我们使用redisson组件来进行优化

Redisson的使用

引入依赖

这里使用的maven，可以自行在maven仓库中搜索最新的版本

        <!--redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.6</version>
        </dependency>

基本配置

@Configuration
public class  RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
     config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("123456");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}

服务器地址，密码等信息

Redisson可重入锁

需要可重入的原因：在上面的图中可以看到，在调用thread1的用户信息时，我已经在method1中拿到了锁，但是我在method1中还需要调用method2，但是也需要获取锁，所以我需要可重入的使用锁

对此可以想到，在我们记录线程标识的同时，记录拿到锁的次数，每次都加1，当释放锁的时候，再减1，这样就可以实现锁的重入，为了满足原子性，我们需要使用lua脚本实现


其中redisson已经将其封装，我们只需要调用

lock.trylock() 获取锁
lock.unlock() 释放锁

Redisson 解决超时释放，不可重试

lock.trylock() 获取锁
lock.unlock() 释放锁

在获取锁的api中存在可实行参数，可以解决，但是对于底层源码，后续在进行补充

Redisson 主从一致性

在集群模式中，我们只需要对于每一个redis服务都进行获取锁的操作，若都获取成果才算成功，只要有一个不成功，则为失败

总结