商城项目【尚品汇】07分布式锁-2 Redisson篇

1 Redisson功能介绍

基于自定义setnx实现的分布式锁存在下面的问题：

重入问题：重入问题是指 获得锁的线程可以再次进入到相同的锁的代码块中，可重入锁的意义在于防止死锁，比如HashTable这样的代码中，他的方法都是使用synchronized修饰的，假如他在一个方法内，调用另一个方法，那么此时如果是不可重入的，不就死锁了吗？所以可重入锁他的主要意义是防止死锁，我们的synchronized和Lock锁都是可重入的。

不可重试：是指目前的分布式只能尝试一次，我们认为合理的情况是：当线程在获得锁失败后，他应该能再次尝试获得锁。

**超时释放：**我们在加锁时增加了过期时间，这样的我们可以防止死锁，但是如果卡顿的时间超长，虽然我们采用了lua表达式防止删锁的时候，误删别人的锁，但是毕竟没有锁住，有安全隐患

主从一致性： 如果Redis提供了主从集群，当我们向集群写数据时，主机需要异步的将数据同步给从机，而万一在同步过去之前，主机宕机了，就会出现死锁问题。

那么什么是Redisson呢

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。

Redission提供了分布式锁的多种多样的功能

2 Redisson在Springboot中快速入门（代码）

2.1 导入依赖

<!-- redisson -->
<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.15.3</version>
</dependency>
1
2
3
4
5
6

2.2 Redisson配置

package com.atguigu.gmall.common.config;

import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

/**
 * redisson配置信息
 */
@Data
@Configuration
@ConfigurationProperties("spring.redis")
public class RedissonConfig {

    private String host;

    private String addresses;

    private String password;

    private String port;

    private int timeout = 3000;
    private int connectionPoolSize = 64;
    private int connectionMinimumIdleSize=10;
    private int pingConnectionInterval = 60000;
    private static String ADDRESS_PREFIX = "redis://";

    /**
     * 自动装配
     *
     */
    @Bean
    RedissonClient redissonSingle() {
        Config config = new Config();
        if(StringUtils.isEmpty(host)){
            throw new RuntimeException("host is  empty");
        }
        SingleServerConfig serverConfig = config.useSingleServer()
                //redis://127.0.0.1:7181
                .setAddress(ADDRESS_PREFIX + this.host + ":" + port)
                .setTimeout(this.timeout)
                .setPingConnectionInterval(pingConnectionInterval)
                .setConnectionPoolSize(this.connectionPoolSize)
                .setConnectionMinimumIdleSize(this.connectionMinimumIdleSize)
                ;
        if(!StringUtils.isEmpty(this.password)) {
            serverConfig.setPassword(this.password);
        }
        // RedissonClient redisson = Redisson.create(config);
        return Redisson.create(config);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

2.3 将自定义锁setnx换成Redisson实现（可重入锁）

实现类详细看这个章节：https://blog.csdn.net/yu_fu_a_bu/article/details/139408497

    @GetMapping("testRedisLock")
    public Result testRedisLock(){
        testLockService.testRedisLock();
        return Result.ok();
    }
1
2
3
4
5

    @Autowired
    private RedissonClient redissonClient;

    @Override
    public void testRedisson() {
        //创建可重入锁对象，并指定锁的名称
        RLock lock = redissonClient.getLock("redisson:1");
        //获取锁，循环重试的时间，逻辑过期时间，时间单位
        boolean isLock = false;
        try {
            isLock = lock.tryLock(1, 10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("获取锁出现异常");
        }

        //获取锁成功，执行业务逻辑
        if (isLock){
            try{
                //从缓存中获取值
                String num = stringRedisTemplate.opsForValue().get("redissonLock");
                //加1操作
                int i = Integer.parseInt(num)+1;
                String s = StringUtil.toString(i);
                //存储到redis中
                stringRedisTemplate.opsForValue().set("redissonLock",s);
            }finally {
                //只有获取到锁的线程，才去释放锁，
                lock.unlock();
            }

        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

测试：

ab -n 5000 -c 100 http://192.168.142.1:81/admin/product/testLock/testRedisson

3 可重入锁原理

3.1 自定义分布式锁setnx为什么不可以重入

数据结构：key-value的形式。String类型

public class DistributedLockExample {
    
    private static Jedis jedis = new Jedis("127.0.0.1", 6379);

    public void acquireLock(String lockKey) {
        Boolean locked = jedis.setnx(lockKey, "true");
        if (locked) {
            System.out.println("Lock acquired successfully.");
        } else {
            System.out.println("Lock already acquired by another process.");
        }
    }

    public static void main(String[] args) {
        DistributedLockExample example = new DistributedLockExample();
        example.acquireLock("myLock");
        example.acquireLock("myLock"); // 尝试重入
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在上面的示例中，acquireLock方法通过setnx尝试获取锁。第一次调用acquireLock时成功获取锁，因为myLock这个key在Redis中不存在。第二次调用acquireLock尝试重入时，会返回锁已被占用的提示，因为Redis的setnx指令无法识别重入情况，每次获取锁都需要先检查是否已被占用。

3.2 redisson为什么可以实现可重入

数据类型：key-value(field-value) Hash类型

不仅存入线程标识（保证不删除别人的锁），而且存入可重入的次数（保证可重入）。

3.2.1 获取锁的lua脚本

lua脚本可以保证原子性

local key = KEYS[1];--锁的key
local threadId = ARGV[1]; --线程的唯一标识
local releaseTime = ARGV[2];--锁的自动释放时间
--判断锁是否存在
if(redis.call('exists',key) == 0) then 
	--不存在，获取锁
	redis.call('hset', key,threadId,'1');
	--设置有效期
	redis.call('expire',key,releaseTime);
	return 1;--返回结果
end;
--如果锁已经存在，判断threadId是否是自己的
if(redis.call('hexists',key,threadId) == 1) then
	--存在，获取锁，重入次数加一
	redis.call('hincrby',key,threadId,'1');
	-- 设置有效期
	redis.call('expire',key,releaseTime);
	return 1;--返回结果
end;
return 0;--获取锁失败
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.2.2 释放锁的lua脚本

local key = KEYS[1];--锁的key
local threadId = ARGV[1]; --锁的唯一标识
local releaseTime = ARGV[2];--锁的自动释放时间
-- 判断锁是还是被自己持有
if(redis.call('HEXISTS',key,threadId) == 0) then 
	return nil;--如果已经不是自己，则直接返回
end;
-- 是自己的锁，则可重入的次数进行-1
local count = redis.call('HINCRVY',key,threadId,-1);
-- 判断可重入的次数是否为0
if(count > 0){
	-- 大于0说明不能释放锁，重置过期时间然后返回
	redis.call('EXPIRE',key,releaseTime);
	return nil;
else --等于0说明可以释放锁，直接删除
	redis.call('DEL',key);
	return nil;
end;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18