redis分布式锁的应用场景_redis为什么可以做分布式锁

redis分布式锁的应用场景_redis为什么可以做分布式锁“分布式锁”是用来解决分布式应用中“并发冲突”的一种常用手段,实现方式一般有基于zookeeper及基于redis二种。具体到业务场景中,我们要考虑二种情况:一、抢不到锁的请求,允许丢弃(即:忽略)比如:一些不是很重要的场景,比如“监控数据持续上报”,某一篇文章的“已读/未读”标识位更新,对于同一个id,如果并发的请求同时到达,只要有一个请求处理成功,就算成功。用活动图表示如下:二、并发请求,不论哪一条都必须要处理的场景(即:不允许丢数据)比如:一个订单,客户正在前台修改地址,.

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

“分布式锁”是用来解决分布式应用中“并发冲突”的一种常用手段,实现方式一般有基于zookeeper及基于redis二种。

这里我们分析下基于redis得场景和实现。

单节点部署场景

  • 举例说明,系统A和系统B是两个部署在不同节点的相同应用(集群部署),这时客户端请求传来,两个系统都受到了请求,并且该请求是对数据表进行插入操作,如果这个时候不加锁来控制,可能会导致数据库新增两条记录,这时系统也不能允许的,由于是在不同应用内,在单个应用内加JVM级别的锁,另一个应用是感知不到的,这时需要用到分布式锁。
  • 接下来我们看看这种场景如何实现安全的分布式锁,由于是单节点部署场景,我们可以用setnx命令,以请求的唯一主键作为key,由于该操作是原子操作,当系统A设值成功后,系统B是无法设置成功的, 这时A就可以进行查询并插入操作,操作数据库完成后,删除key,此时系统B才能设值成功,但是由于查询到数据库有记录,所以并不会插入数据,这样就解决了该问题。但是这里会有个问题,如果redis挂机了,这里的锁不是永远都不释放了吗, 所以为了解决这个问题,redis提供了set命令,可传入超时时间的,那么在指定的时间范围内,如果没有释放锁,则该锁自动过期。如果执行时间超过超时时间呢,比如系统A还未执行完任务,就释放了锁,系统B接着执行任务,这时,系统A执行完了,把锁删掉(此时删除的时系统B获取的锁)。
    • 方案一: 为了避免这种情况,在del锁之前可以做一个判断,验证key对应的value是不是自己线程的ID.如果要考虑原子性问题,可以使用Lua脚本来实现,保证验证和删除的原子性。
    • 方案二:我们可以让获得锁的线程开启一个守护线程,用来给快要过期的锁加长超时时间。当系统A中的线程执行完任务,再显式关掉守护线程。

具体到业务场景中,我们要考虑二种情况:

一、抢不到锁的请求,允许丢弃(即:忽略)

比如:一些不是很重要的场景,比如“监控数据持续上报”,某一篇文章的“已读/未读”标识位更新,对于同一个id,如果并发的请求同时到达,只要有一个请求处理成功,就算成功。

用活动图表示如下:

点击查看原图

 

二、并发请求,不论哪一条都必须要处理的场景(即:不允许丢数据)

比如:一个订单,客户正在前台修改地址,管理员在后台同时修改备注。地址和备注字段的修改,都必须正确更新,这二个请求同时到达的话,如果不借助db的事务,很容易造成行锁竞争,但用事务的话,db的性能显然比不上redis轻量。

解决思路:A,B二个请求,谁先抢到分布式锁(假设A先抢到锁),谁先处理,抢不到的那个(即:B),在一旁不停等待重试,重试期间一旦发现获取锁成功,即表示A已经处理完,把锁释放了。这时B就可以继续处理了。

但有二点要注意:

a、需要设置等待重试的最长时间,否则如果A处理过程中有bug,一直卡死,或者未能正确释放锁,B就一直会等待重试,但是又永远拿不到锁。

b、等待最长时间,必须小于锁的过期时间。否则,假设锁2秒过期自动释放,但是A还没处理完(即:A的处理时间大于2秒),这时锁会因为redis key过期“提前”误释放,B重试时拿到锁,造成A,B同时处理。(注:可能有同学会说,不设置锁的过期时间,不就完了么?理论上讲,确实可以这么做,但是如果业务代码有bug,导致处理完后没有unlock,或者根本忘记了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

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

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

package com.cnblogs.yjmyzz.redisdistributionlock;

 

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.data.redis.core.StringRedisTemplate;

import org.springframework.util.StringUtils;

 

import java.util.UUID;

import java.util.concurrent.TimeUnit;

 

/**

 * 利用redis获取分布式锁

 *

 * @author 菩提树下的杨过

 * @blog http://yjmyzz.cnblogs.com/

 */

public class RedisLock {

 

    private StringRedisTemplate redisTemplate;

 

    private Logger logger = LoggerFactory.getLogger(this.getClass());

 

    /**

     * simple lock尝试获取锅的次数

     */

    private int retryCount = 3;

 

    /**

     * 每次尝试获取锁的重试间隔毫秒数

     */

    private int waitIntervalInMS = 100;

 

 

    public RedisLock(StringRedisTemplate redisTemplate) {

        this.redisTemplate = redisTemplate;

    }

 

    /**

     * 利用redis获取分布式锁(未获取锁的请求,允许丢弃!)

     *

     * @param redisKey       锁的key值

     * @param expireInSecond 锁的自动释放时间(秒)

     * @return

     * @throws DistributionLockException

     */

    public String simpleLock(final String redisKey, final int expireInSecond) throws DistributionLockException {

        String lockValue = UUID.randomUUID().toString();

        boolean flag = false;

        if (StringUtils.isEmpty(redisKey)) {

            throw new DistributionLockException("key is empty!");

        }

        if (expireInSecond <= 0) {

            throw new DistributionLockException("expireInSecond must be bigger than 0");

        }

        try {

            for (int i = 0; i < retryCount; i++) {

                boolean success = redisTemplate.opsForValue().setIfAbsent(redisKey, lockValue, expireInSecond, TimeUnit.SECONDS);

                if (success) {

                    flag = true;

                    break;

                }

                try {

                    TimeUnit.MILLISECONDS.sleep(waitIntervalInMS);

                catch (Exception ignore) {

                    logger.warn("redis lock fail: " + ignore.getMessage());

 

                }

            }

            if (!flag) {

                throw new DistributionLockException(Thread.currentThread().getName() + " cannot acquire lock now ...");

            }

            return lockValue;

        catch (DistributionLockException be) {

            throw be;

        catch (Exception e) {

            logger.warn("get redis lock error, exception: " + e.getMessage());

            throw e;

        }

    }

 

    /**

     * 利用redis获取分布式锁(未获取锁的请求,将在timeoutSecond时间范围内,一直等待重试)

     *

     * @param redisKey       锁的key值

     * @param expireInSecond 锁的自动释放时间(秒)

     * @param timeoutSecond  未获取到锁的请求,尝试重试的最久等待时间(秒)

     * @return

     * @throws DistributionLockException

     */

    public String lock(final String redisKey, final int expireInSecond, final int timeoutSecond) throws DistributionLockException {

        String lockValue = UUID.randomUUID().toString();

        boolean flag = false;

        if (StringUtils.isEmpty(redisKey)) {

            throw new DistributionLockException("key is empty!");

        }

        if (expireInSecond <= 0) {

            throw new DistributionLockException("expireInSecond must be greater than 0");

        }

        if (timeoutSecond <= 0) {

            throw new DistributionLockException("timeoutSecond must be greater than 0");

        }

        if (timeoutSecond >= expireInSecond) {

            throw new DistributionLockException("timeoutSecond must be less than expireInSecond");

        }

        try {

            long timeoutAt = System.currentTimeMillis() + timeoutSecond * 1000;

            while (true) {

                boolean success = redisTemplate.opsForValue().setIfAbsent(redisKey, lockValue, expireInSecond, TimeUnit.SECONDS);

                if (success) {

                    flag = true;

                    break;

                }

                if (System.currentTimeMillis() >= timeoutAt) {

                    break;

                }

                try {

                    TimeUnit.MILLISECONDS.sleep(waitIntervalInMS);

                catch (Exception ignore) {

                    logger.warn("redis lock fail: " + ignore.getMessage());

                }

            }

            if (!flag) {

                throw new DistributionLockException(Thread.currentThread().getName() + " cannot acquire lock now ...");

            }

            return lockValue;

        catch (DistributionLockException be) {

            throw be;

        catch (Exception e) {

            logger.warn("get redis lock error, exception: " + e.getMessage());

            throw e;

        }

    }

 

 

    /**

     * 锁释放

     *

     * @param redisKey

     * @param lockValue

     */

    public void unlock(final String redisKey, final String lockValue) {

        if (StringUtils.isEmpty(redisKey)) {

            return;

        }

        if (StringUtils.isEmpty(lockValue)) {

            return;

        }

        try {

            String currLockVal = redisTemplate.opsForValue().get(redisKey);

            if (currLockVal != null && currLockVal.equals(lockValue)) {

                boolean result = redisTemplate.delete(redisKey);

                if (!result) {

                    logger.warn(Thread.currentThread().getName() + " unlock redis lock fail");

                else {

                    logger.info(Thread.currentThread().getName() + " unlock redis lock:" + redisKey + " successfully!");

                }

            }

        catch (Exception je) {

            logger.warn(Thread.currentThread().getName() + " unlock redis lock error:" + je.getMessage());

        }

    }

}

  

然后写个spring-boot来测试一下:

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

package com.cnblogs.yjmyzz.redisdistributionlock;

 

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.data.redis.core.StringRedisTemplate;

 

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

 

@SpringBootApplication

public class RedisDistributionLockApplication {

 

    private static Logger logger = LoggerFactory.getLogger(RedisDistributionLockApplication.class);

 

    public static void main(String[] args) throws InterruptedException {

        ConfigurableApplicationContext applicationContext = SpringApplication.run(RedisDistributionLockApplication.class, args);

 

        //初始化

        StringRedisTemplate redisTemplate = applicationContext.getBean(StringRedisTemplate.class);

        RedisLock redisLock = new RedisLock(redisTemplate);

        String lockKey = "lock:test";

 

 

        CountDownLatch start = new CountDownLatch(1);

        CountDownLatch threadsLatch = new CountDownLatch(2);

 

        final int lockExpireSecond = 5;

        final int timeoutSecond = 3;

 

        Runnable lockRunnable = () -> {

            String lockValue = "";

            try {

                //等待发令枪响,防止线程抢跑

                start.await();

 

                //允许丢数据的简单锁示例

                lockValue = redisLock.simpleLock(lockKey, lockExpireSecond);

 

 

                //不允许丢数据的分布式锁示例

                //lockValue = redisLock.lock(lockKey, lockExpireSecond, timeoutSecond);

 

                //停一会儿,故意让后面的线程抢不到锁

                TimeUnit.SECONDS.sleep(2);

                logger.info(String.format("%s get lock successfully, value:%s", Thread.currentThread().getName(), lockValue));

 

            catch (Exception e) {

                e.printStackTrace();

            finally {

                redisLock.unlock(lockKey, lockValue);

                //执行完后,计数减1

                threadsLatch.countDown();

            }

 

        };

 

        Thread t1 = new Thread(lockRunnable, "T1");

        Thread t2 = new Thread(lockRunnable, "T2");

 

        t1.start();

        t2.start();

 

        //预备:开始!

        start.countDown();

 

        //等待所有线程跑完

        threadsLatch.await();

 

        logger.info("======>done!!!");

 

    }

 

}

 用2个线程模拟并发场景,跑起来后,输出如下:

点击查看原图

可以看到T2线程没抢到锁,直接抛出了预期的异常。

把44行的注释打开,即:换成不允许丢数据的模式,再跑一下:

点击查看原图

可以看到,T1先抢到锁,然后经过2秒的处理后,锁释放,这时T2重试拿到了锁,继续处理,最终释放。

 

文章参考:

基于redis的分布式锁二种应用场景

https://www.cnblogs.com/yjmyzz/

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/195984.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 有序的Map集合_map集合特点

    有序的Map集合_map集合特点我们通常使用的Map集合是HashMap,在大多数情况下HashMap可以满足我们的要求,但是HashMap有一个缺点:HashMap是无序的,即其迭代顺序与其key或value的大小无关。而在某些情况下,如果我们需要Map集合里的元素有序,那么HashMap是不能满足我们的要求的。那么有没有有序的Map集合呢?有,Java提供了两种有序的Map集合:LinkedHashMap和TreeM…

  • QUIC简单介绍

    QUIC简单介绍

    2021年12月16日
  • git如何退出vim_git提交的命令

    git如何退出vim_git提交的命令有很多方法:退出Vi当编辑完文件,准备退出Vi返回到shell时,可以使用以下几种方法之一。在命令模式中,连按两次大写字母Z,若当前编辑的文件曾被修改过,则Vi保存该文件后退出,返回到shell;若当前编辑的文件没被修改过,则Vi直接退出,返回到shell。在末行模式下,输入命令:wVi保存当前编辑文件,但并不退出,而是继续等待用户输入命令。在使用

  • 〖教程〗Ladon 0day通用执行命令DLL生成器-MS17010演示[通俗易懂]

    〖教程〗Ladon 0day通用执行命令DLL生成器-MS17010演示[通俗易懂]Ladon8.9更新功能20210920[+]CmdDllWindows0day漏洞通用DLL注入生成器,生成的DLL仅5KB,非常适合0day加载2021.9.15[u]webscanCS保留[u]CmdDll去除黑框2021.9.14[+]CVE-2021-40444MicrosoftMSHTML远程代码执行漏洞,Office文档利用模块影响版本:包括Windows7/8/8.1/10,WindowsServer2008/2008R2/2012/2012R2/2016

  • VB实现关机程序

    VB实现关机程序下面是本人愿来写的关机程序可以适用于98/xp/2000,在程序中调用即可。现在操作系统多为2000或xp,所以需要特别注意的是应该先得到关机的特权:(要想弄懂下面的程序,先要具备vb调用api函数的知识……)其中:前面一些Public Declare都是api函数的声明.     Public Sub AdjustToken()子程序用来取得关机特权.     Public Sub Sh

  • IIC通信协议技术说明

    IIC通信协议技术说明简介IICBus最早是Philips半导体开发的两线时串行总线,经常用于微控制器和外设之间的连接。IIC通信方式为半双工,只有一根SDA线,同一时间只可以单向通信,485为半双工,SPI和UART为全双工。网络拓扑SDA:串行数据线SCL:串行时钟线数据传输每个字节传输必须带有响应位ACK,相关的响应时钟也有主机产生,在响应的时钟脉冲期间(第9个时钟周期),发送端释放SDA线,接收端把SDA拉低。SCL第9位时钟高电平信号期间,SDA拉低代表了有ACK响应位。当出现非响应NACK位:

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号