devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

分布式锁之redis实现方案_redis分布式锁实现方案

作者：花生_TL007 | 2024-05-01 10:01:43

赞

踩

redis分布式锁实现方案

一、什么是分布式锁？

为了保证一个方法或属性在高并发情况下的同一时间只能被同一个线程执行，由于分布式系统多线程、多进程并且分布在不同机器上，需要一种跨机器的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！

二、分布式锁应该具备哪些条件

在分析分布式锁的三种实现方式之前，先了解一下分布式锁应该具备哪些条件：
1、在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行；
2、高可用的获取锁与释放锁；
3、高性能的获取锁与释放锁；
4、具备可重入特性；
5、具备锁失效机制，防止死锁；
6、具备非阻塞锁特性，即没有获取到锁将直接返回获取锁失败。

三、分布式锁的三种实现方式

目前几乎很多大型网站及应用都是分布式部署的，分布式场景中的数据一致性问题一直是一个比较重要的话题。分布式的CAP理论告诉我们“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。所以，很多系统在设计之初就要对这三者做出取舍。在互联网领域的绝大多数的场景中，都需要牺牲强一致性来换取系统的高可用性，系统往往只需要保证“最终一致性”，只要这个最终时间是在用户可以接受的范围内即可。
在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。有的时候，我们需要保证一个方法在同一时间内只能被同一个线程执行。

基于数据库实现分布式锁；
基于缓存（Redis等）实现分布式锁；
基于Zookeeper实现分布式锁；

四、基于Redis的实现方式

1、选用Redis实现分布式锁原因：

（1）Redis有很高的性能；
（2）Redis命令对此支持较好，实现起来比较方便

2、使用命令介绍：

（1）SETNX

SETNX key val：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。

（2）expire

expire key timeout：为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。

（3）delete

delete key：删除key
在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。

3、实现思想：

（1）获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
（2）获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
（3）释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

五、代码实现：

pom文件：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.example</groupId>
  6.     <artifactId>redisLock</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <name>redisLock</name>
  9.     <description>redisLock</description>
  10.  
  11.     <properties>
  12.         <java.version>1.8</java.version>
  13.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  14.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  15.         <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
  16.     </properties>
  17.  
  18.     <dependencies>
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter</artifactId>
  22.         </dependency>
  23.  
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-test</artifactId>
  27.             <scope>test</scope>
  28.             <exclusions>
  29.                 <exclusion>
  30.                     <groupId>org.junit.vintage</groupId>
  31.                     <artifactId>junit-vintage-engine</artifactId>
  32.                 </exclusion>
  33.             </exclusions>
  34.         </dependency>
  35.  
  36.         <!-- redis -->
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-data-redis</artifactId>
  40.         </dependency>
  41.  
  42.         <!-- spring2.X集成redis所需common-pool2-->
  43.         <dependency>
  44.             <groupId>org.apache.commons</groupId>
  45.             <artifactId>commons-pool2</artifactId>
  46.             <version>2.6.0</version>
  47.         </dependency>
  48.  
  49.         <!-- redisson 分布式锁-->
  50.         <dependency>
  51.             <groupId>org.redisson</groupId>
  52.             <artifactId>redisson</artifactId>
  53.             <version>3.11.2</version>
  54.         </dependency>
  55.         <dependency>
  56.             <groupId>org.springframework.boot</groupId>
  57.             <artifactId>spring-boot-starter-web</artifactId>
  58.         </dependency>
  59.  
  60.  
  61.     </dependencies>
  62.  
  63.     <dependencyManagement>
  64.         <dependencies>
  65.             <dependency>
  66.                 <groupId>org.springframework.boot</groupId>
  67.                 <artifactId>spring-boot-dependencies</artifactId>
  68.                 <version>${spring-boot.version}</version>
  69.                 <type>pom</type>
  70.                 <scope>import</scope>
  71.             </dependency>
  72.         </dependencies>
  73.     </dependencyManagement>
  74.  
  75.     <build>
  76.         <plugins>
  77.             <plugin>
  78.                 <groupId>org.apache.maven.plugins</groupId>
  79.                 <artifactId>maven-compiler-plugin</artifactId>
  80.                 <version>3.8.1</version>
  81.                 <configuration>
  82.                     <source>1.8</source>
  83.                     <target>1.8</target>
  84.                     <encoding>UTF-8</encoding>
  85.                 </configuration>
  86.             </plugin>
  87.             <plugin>
  88.                 <groupId>org.springframework.boot</groupId>
  89.                 <artifactId>spring-boot-maven-plugin</artifactId>
  90.                 <version>2.3.7.RELEASE</version>
  91.                 <configuration>
  92.                     <mainClass>com.example.redislock.RedisLockApplication</mainClass>
  93.                 </configuration>
  94.                 <executions>
  95.                     <execution>
  96.                         <id>repackage</id>
  97.                         <goals>
  98.                             <goal>repackage</goal>
  99.                         </goals>
  100.                     </execution>
  101.                 </executions>
  102.             </plugin>
  103.         </plugins>
  104.     </build>
  105.  
  106. </project>

yml：

  1. server:
  2.   #port: 8206
  3. spring:
  4.   redis:
  5.     host: 192.168.247.100
  6.     port: 6379
  7.     database: 0
  8.     timeout: 1800000
  9.     lettuce:
  10.       pool:
  11.         max-active: 20 #最大连接数
  12.         max-wait: -1    #最大阻塞等待时间(负数表示没限制)
  13.         max-idle: 5    #最大空闲
  14.         min-idle: 0     #最小空闲

操作reids代码：

  1. package com.example.redislock.service.impl;
  2.  
  3. import com.example.redislock.service.TestService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.StringRedisTemplate;
  6. import org.springframework.data.redis.core.script.DefaultRedisScript;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.util.StringUtils;
  9.  
  10. import java.util.Arrays;
  11. import java.util.UUID;
  12. import java.util.concurrent.TimeUnit;
  13.  
  14. @Service
  15. public class TestServiceImpl implements TestService {
  16.  
  17.     @Autowired
  18.     private StringRedisTemplate redisTemplate;
  19.  
  20.     /**
  21.      * 最初版，单一部署 synchronized锁
  22.      * 在缓存中存储一个num，初始值为0
  23.      * 利用缓存中的StringRedisTemplate，获取到当前的num数据值
  24.      * 如果num不为空，则需要对当前值+1操作
  25.      * 如果num为空，返回即可
  26.      */
  27. //    @Override
  28. //    public synchronized void testLock() {
  29. //        // 利用缓存中的StringRedisTemplate，获取到当前的num数据值
  30. //        String num = redisTemplate.opsForValue().get("num");
  31. //        if (StringUtils.isEmpty(num)) {
  32. //            return;
  33. //        }
  34. //        // 如果num不为空，则需要对当前值+1操作
  35. //        int numValue = Integer.parseInt(num);
  36. //        // 写回缓存
  37. //        redisTemplate.opsForValue().set("num", String.valueOf(++numValue));
  38. //    }
  39.  
  40.     /**
  41.      * 使用redis分布式锁版
  42.      */
  43.     @Override
  44.     public void testLock() {
  45.         // setnx获取锁时，设置一个指定的唯一值（例如：uuid）；释放前获取这个值，判断是否自己的锁。
  46.         String uid = UUID.randomUUID().toString();
  47.         // 1. 使用setnx命令     setnx lock ok,并设置过期时间 3m(设置过期时间，自动释放锁。)
  48.         Boolean flag = redisTemplate.opsForValue().setIfAbsent("lock",uid,3, TimeUnit.MINUTES);
  49.         // 2. 判断flag是否为true；
  50.         if(flag){
  51.             // flag = true 表示获取到锁，执行业务
  52.             String num = redisTemplate.opsForValue().get("num");
  53.             //如果num没有设置初始值，则不执行业务
  54.             if(StringUtils.isEmpty(num)){
  55.                 return;
  56.             }
  57.             int newnum = Integer.parseInt(num);
  58.             redisTemplate.opsForValue().set("num", String.valueOf(++newnum));
  59.             // 释放lock锁
  60.             // 定义一个lua脚本,保证删除的原子性
  61. //            String secript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
  62. //            //  准备执行lua 脚本
  63. //            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
  64. //            // 设置lua脚本
  65. //            redisScript.setScriptText(secript);
  66. //            // 设置DefaultRedisScript 这个对象的泛型
  67. //            redisScript.setResultType(Long.class);
  68.             //  redis调用lua脚本
  69. //            redisTemplate.execute(redisScript, Arrays.asList("lock"), uid);
  70.             // 释放lock锁
  71.             if(uid.equals(redisTemplate.opsForValue().get("lock"))){
  72.                 redisTemplate.delete("lock");
  73.             }
  74.         }else {
  75.             // 没有获取到锁
  76.             try {
  77.                 Thread.sleep(100);
  78.                 // 每隔1秒钟回调一次，再次尝试获取锁（自旋）
  79.                 testLock();
  80.             } catch (InterruptedException e) {
  81.                 throw new RuntimeException(e);
  82.             }
  83.         }
  84.  
  85.     }
  86.  
  87. }

最后总结

为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：

互斥性。在任意时刻，只有一个客户端能持有锁；
不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁；
解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了；
加锁和解锁必须具有原子性

感谢俩位老哥博客的指点：

(30条消息) 使用 Redis 实现分布式锁案例_SuZhan0711的博客-CSDN博客_redis分布式锁使用实例

什么是分布式锁？实现分布式锁的三种方式 - 刘清政 - 博客园 (cnblogs.com) 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/518264
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号