Redis分布式锁探究

浏览次数:

1.分布式锁注意的问题

  1. 保证redis命令的原子性操作，即过期时间和key的设置要在一个原子操作范围内，常见就是setnx key value EX NX
  2. 在保证原子性的同时，要对key设置过期时间，防止程序某个环节挂了，导致锁未被释放的问题。
  3. 一个线程执行完操作删除key时，要保证是同一个线程删除同一个key，即使用value做唯一的id，根据value进行删除，防止锁被其他线程删除。
  4. 有可能出现在锁过期后都没有执行完当前线程的操作，这就需要实现锁过期时间的延续，即当前拥有锁的线程会有一个监视器，会以当前设置的key的过期时间的1/3时间进行key的过期时间的延长，，直到当前线程执行完成。这里主要使用Redisson的RedLock实现，里面自动封装了分布式锁的具体操作。(这里就不需要使用set了，直接对key进行lock和unlock)
  5. 在解决以上问题后，后面可能就要考虑分布式锁的性能问题了，由于使用分布式锁是让多个并发线程微观上一个一个执行，且redis执行基本命令是单线程的，所以我们可以对同一商品进行在redis中的划分，比如10000个商品供用户抢，我们原先通过一个key来锁10000，效率自然不是很高，我们可以在redis中通过划分，划分10个key，每个key对应1000个请求，这样十个线程可以一起并发，相当于有了十个锁。有十个队列在进行，性能会比一个队列多了10倍左右。原理类似于currentHashmap的分段锁。
  6. 上述是在单一redis服务器时会面临的问题，对于集群，则会出现新的问题，比如，当master上的key已经加锁，此时还未同步到slave，master挂了，这时就会造成锁丢失了，新的master会重新获取锁，这样就重复获取锁了，解决办法还是利用Redisson的redLock的集群方式解决。

2.实现操作

a.spring boot redisTemplate解决（单一）

(1)自定义redisTemplate

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
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    @SuppressWarnings("all")
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 为了方便开发，一般直接使用<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //String序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采取String的方式序列化
        template.setKeySerializer(stringRedisSerializer);
        // hash的key采用String方式序列化
        template.setHashKeySerializer(stringRedisSerializer);
        // value的序列化方式选择jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

(2)分布式锁实现

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
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

public class RedisDistributedLockBySpringBootRedisTemplate {
    private String lockKey;
    private String token;
    private int lockExpireTime;

    @Autowired
    private RedisTemplate redisTemplate;

    public RedisDistributedLockBySpringBootRedisTemplate() {
    }

    public RedisDistributedLockBySpringBootRedisTemplate(String lockKey, int lockExpireTime) {
        this.lockKey = lockKey;
        this.lockExpireTime = lockExpireTime;
    }

    // 注意，lock和unlock要在业务代码中加try{}finally{},保证解锁
    public String lock() {
        token = UUID.randomUUID().toString();
        boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, token, lockExpireTime, TimeUnit.MILLISECONDS);
        if (result) {
            return token;
        }

        return null;
    }

    public boolean unlock(String lockKey, String token) {
        if (lockKey == null || token == null) {
            return false;
        }
        if (token.equals(redisTemplate.opsForValue().get(lockKey))) {
            redisTemplate.delete(lockKey);
            return true;
        }

        return false;
    }


}

b.jdeis解决（单一）

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import java.util.Collections;
import java.util.UUID;

// 单一服务器分布式锁
public class RedisDistributedLockByJedis {
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";
    private static final Long RELEASE_SUCCESS = 1L;
    private static final String LOCK_SUCCESS = "OK";
    private static final int SLEEP_TIME = 100;

    private String lockKey;
    private String token;
    private int lockExpireTime = 1 * 1000;
    private int threadWaitTime = 1 * 1000;
    private Jedis jedis;


    public RedisDistributedLockByJedis() {
    }

    public RedisDistributedLockByJedis(Jedis jedis, String lockKey, String token, int lockExpireTime, int threadWaitTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.token = token;
        this.lockExpireTime = lockExpireTime;
        this.threadWaitTime = threadWaitTime;
    }

    // jedis 2.9.0以下支持set
    public String lock() {
        try {
            // 获取锁的超时时间
            long timeout = System.currentTimeMillis() + threadWaitTime;
            // 使用token做唯一标识，防止其他线程删除锁，一对一的删除
            String token = UUID.randomUUID().toString().replace("-", "");
            // 再当前线程获取锁的超时时间范围内不断获取锁，sleep的目的是给其他线程获取锁的机会，有一个线程获得机会后，其他线程就得不到锁了
            while (System.currentTimeMillis() < timeout) {
                // 根据过期时间以及key和value去获取锁
                String result = jedis.set(lockKey, token, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, lockExpireTime);
                if (LOCK_SUCCESS.equals(result)) {
                    return token;
                }

                try {
                    Thread.sleep(SLEEP_TIME);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

    public boolean unlock(String token) {
        if (StringUtils.isEmpty(token)) {
            return false;
        }

        // 使用lua脚本保证原子性，同时，根据唯一的value删除key
        String lua = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        try {
            if (RELEASE_SUCCESS.equals(jedis.eval(lua, Collections.singletonList(lockKey), Collections.singletonList(token)))) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 一定要关闭
            if (jedis != null) {
                jedis.close();
            }
        }

        return false;
    }


}

c.redisson解决（集群）

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
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;


// 分布式的锁，对应集群
public class RedisDistributedLockByRedisson {
    private RedissonClient redissonClient;
    private RLock redLock;
    private int lockExpireTime = 1 * 1000;
    private int threadWaitTime = 1 * 1000;
    private String lockKey;

    public RedisDistributedLockByRedisson(RedissonClient redissonClient, String lockKey) {
        this.redissonClient = redissonClient;
        this.lockKey = lockKey;
    }

    public void lock() {
        redLock = redissonClient.getLock(lockKey);
        try{
            redLock.tryLock(threadWaitTime, lockExpireTime, TimeUnit.MILLISECONDS);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public boolean unlock() {
        if(redLock != null) {
            redLock.unlock();
            return true;
        }
        return false;
    }


}

3.依赖导入

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
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.4.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.16</version>
        <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>2.4.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.14.0</version>
    </dependency>

参考：

https://juejin.cn/post/6844903830442737671

https://mp.weixin.qq.com/s/8uhYult2h_YUHT7q7YCKYQ

https://mp.weixin.qq.com/s?__biz=MzU5ODUwNzY1Nw==&mid=2247484155&idx=1&sn=0c73f45f2f641ba0bf4399f57170ac9b&scene=21#wechat_redirect

https://www.cnblogs.com/zhili/p/redisdistributelock.html

https://www.cnblogs.com/zhili/p/redLock_DistributedLock.html

https://juejin.cn/post/6844903682908110855

https://www.cnblogs.com/mcbye/p/Jedis-VS-Redisson.html

赏

Thank you,么么哒

支付宝
微信

扫一扫，分享到微信

微信分享二维码
TotalVisits: | Visitors:

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

欢迎来到Zcoder的博客！！！