Springboot使用Redis实现分布式锁

逃离我推掉我的手 2023-02-16 01:42 115阅读 0赞

基于 redis的 SETNX()、EXPIRE() 方法做分布式锁

-SETNX()
setnx接收两个参数key，value。如果key存在，则不做任何操作，返回0，若key不存在，则设置成功，返回1。
-EXPIRE()
expire 设置过期时间，要注意的是 setnx 命令不能设置 key 的超时时间，只能通过 expire() 来对 key 设置。

注意：

1.加锁过程必须设置过期时间，加锁和设置过期时间过程必须是原子操作
如果没有设置过期时间，那么就发生死锁，锁永远不能被释放。如果加锁后服务宕机或程序崩溃，来不及设置过期时间，同样会发生死锁。
2.解锁必须是解除自己加上的锁
试想一个这样的场景，服务A加锁，但执行效率非常慢，导致锁失效后还未执行完，但这时候服务B已经拿到锁了，这时候服务A执行完毕了去解锁，把服务B的锁给解掉了，其他服务C、D、E…都可以拿到锁了，这就有问题了。加锁的时候我们可以设置唯一value，解锁时判断是不是自己先前的value就行了。

项目目录结构：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70

pom.xml

  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.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.3.0.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.cxb</groupId>
  12.     <artifactId>redis</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>redis-lock</name>
  15.     <description>Demo project for Spring Boot</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  21.     <dependencies>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-web</artifactId>
  25.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-test</artifactId>
  30.             <scope>test</scope>
  31.             <exclusions>
  32.                 <exclusion>
  33.                     <groupId>org.junit.vintage</groupId>
  34.                     <artifactId>junit-vintage-engine</artifactId>
  35.                 </exclusion>
  36.             </exclusions>
  37.         </dependency>
  39.         <!-- redis依赖 -->
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-starter-cache</artifactId>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>org.springframework.boot</groupId>
  46.             <artifactId>spring-boot-starter-data-redis</artifactId>
  47.             <exclusions>
  48.                 <!-- 不依赖Redis的异步客户端lettuce -->
  49.                 <exclusion>
  50.                     <groupId>io.lettuce</groupId>
  51.                     <artifactId>lettuce-core</artifactId>
  52.                 </exclusion>
  53.             </exclusions>
  54.         </dependency>
  56.         <dependency>
  57.             <groupId>redis.clients</groupId>
  58.             <artifactId>jedis</artifactId>
  59.             <version>3.0.1</version>
  60.         </dependency>
  62.         <dependency>
  63.             <groupId>org.apache.commons</groupId>
  64.             <artifactId>commons-pool2</artifactId>
  65.             <version>2.5.0</version>
  66.         </dependency>
  68.     </dependencies>
  70.     <build>
  71.         <plugins>
  72.             <plugin>
  73.                 <groupId>org.springframework.boot</groupId>
  74.                 <artifactId>spring-boot-maven-plugin</artifactId>
  75.             </plugin>
  76.         </plugins>
  77.     </build>
  79. </project>

application.properties

  1. # Redis数据库索引（默认为0）
  2. spring.redis.database=0
  3. # Redis服务器地址
  4. spring.redis.host=127.0.0.1
  5. # Redis服务器连接端口
  6. spring.redis.port=6379
  7. # Redis服务器连接密码（默认为空）
  8. spring.redis.password=
  9. # 连接池最大连接数（使用负值表示没有限制）
  10. spring.redis.pool.max-active=200
  11. # 连接池最大阻塞等待时间（使用负值表示没有限制）
  12. spring.redis.pool.max-wait=-1
  13. # 连接池中的最大空闲连接
  14. spring.redis.pool.max-idle=10
  15. # 连接池中的最小空闲连接
  16. spring.redis.pool.min-idle=1
  17. # 连接超时时间（毫秒）
  18. spring.redis.timeout=10000
  19. #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
  20. redis.testOnBorrow=true  
  21. #在空闲时检查有效性, 默认false
  22. redis.testWhileIdle=true 
  24. server.port=8082
  26. RedisConfig
  28. package com.cxb.redis;
  30. import org.springframework.beans.factory.annotation.Autowired;
  31. import org.springframework.context.annotation.Bean;
  32. import org.springframework.context.annotation.Configuration;
  33. import org.springframework.data.redis.connection.RedisConnectionFactory;
  34. import org.springframework.data.redis.core.*;
  35. import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
  36. import org.springframework.data.redis.serializer.StringRedisSerializer;
  38. @Configuration
  39. public class RedisConfig {
  41.     /**
  42.      * 注入 RedisConnectionFactory
  43.      */
  44.     @Autowired
  45.     RedisConnectionFactory redisConnectionFactory;
  47.     /**
  48.      * 实例化 RedisTemplate 对象
  49.      *
  50.      * @return
  51.      */
  52.     @Bean
  53.     public RedisTemplate<String, Object> functionDomainRedisTemplate() {
  54.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  55.         initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
  56.         return redisTemplate;
  57.     }
  59.     /**
  60.      * 设置数据存入 redis 的序列化方式
  61.      *
  62.      * @param redisTemplate
  63.      * @param factory
  64.      */
  65.     private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
  66.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  67.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  68.         redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
  69.         redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
  70.         redisTemplate.setConnectionFactory(factory);
  71.     }
  73.     /**
  74.      * 实例化 HashOperations 对象,可以使用 Hash 类型操作
  75.      *
  76.      * @param redisTemplate
  77.      * @return
  78.      */
  79.     @Bean
  80.     public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
  81.         return redisTemplate.opsForHash();
  82.     }
  84.     /**
  85.      * 实例化 ValueOperations 对象,可以使用 String 操作
  86.      *
  87.      * @param redisTemplate
  88.      * @return
  89.      */
  90.     @Bean
  91.     public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
  92.         return redisTemplate.opsForValue();
  93.     }
  95.     /**
  96.      * 实例化 ListOperations 对象,可以使用 List 操作
  97.      *
  98.      * @param redisTemplate
  99.      * @return
  100.      */
  101.     @Bean
  102.     public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
  103.         return redisTemplate.opsForList();
  104.     }
  106.     /**
  107.      * 实例化 SetOperations 对象,可以使用 Set 操作
  108.      *
  109.      * @param redisTemplate
  110.      * @return
  111.      */
  112.     @Bean
  113.     public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
  114.         return redisTemplate.opsForSet();
  115.     }
  117.     /**
  118.      * 实例化 ZSetOperations 对象,可以使用 ZSet 操作
  119.      *
  120.      * @param redisTemplate
  121.      * @return
  122.      */
  123.     @Bean
  124.     public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
  125.         return redisTemplate.opsForZSet();
  126.     }
  127. }
  129. RedisLock
  131. package com.cxb.redis;
  133. import org.springframework.data.redis.connection.RedisConnection;
  134. import org.springframework.data.redis.connection.RedisConnectionFactory;
  135. import org.springframework.data.redis.connection.RedisStringCommands;
  136. import org.springframework.data.redis.connection.ReturnType;
  137. import org.springframework.data.redis.core.RedisConnectionUtils;
  138. import org.springframework.data.redis.core.StringRedisTemplate;
  139. import org.springframework.data.redis.core.types.Expiration;
  140. import org.springframework.stereotype.Repository;
  142. import java.nio.charset.Charset;
  143. import java.util.UUID;
  144. import java.util.concurrent.TimeUnit;
  146. @Repository
  147. public class RedisLock {
  149.     /**
  150.      * 解锁脚本，原子操作
  151.      */
  152.     private static final String unlockScript =
  153.             "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n"
  154.                     + "then\n"
  155.                     + "    return redis.call(\"del\",KEYS[1])\n"
  156.                     + "else\n"
  157.                     + "    return 0\n"
  158.                     + "end";
  160.     private StringRedisTemplate redisTemplate;
  162.     public RedisLock(StringRedisTemplate redisTemplate) {
  163.         this.redisTemplate = redisTemplate;
  164.     }
  166.     /**
  167.      * 加锁，有阻塞
  168.      * @param name
  169.      * @param expire
  170.      * @param timeout
  171.      * @return
  172.      */
  173.     public String lock(String name, long expire, long timeout){
  174.         long startTime = System.currentTimeMillis();
  175.         String token;
  176.         do{
  177.             token = tryLock(name, expire);
  178.             if(token == null) {
  179.                 if((System.currentTimeMillis()-startTime) > (timeout-50))
  180.                     break;
  181.                 try {
  182.                     Thread.sleep(50); //try 50 per sec
  183.                 } catch (InterruptedException e) {
  184.                     e.printStackTrace();
  185.                     return null;
  186.                 }
  187.             }
  188.         }while(token==null);
  190.         return token;
  191.     }
  193.     /**
  194.      * 加锁，无阻塞
  195.      * @param name
  196.      * @param expire
  197.      * @return
  198.      */
  199.     public String tryLock(String name, long expire) {
  200.         String token = UUID.randomUUID().toString();
  201.         RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
  202.         RedisConnection conn = factory.getConnection();
  203.         try{
  204.             Boolean result = conn.set(name.getBytes(Charset.forName("UTF-8")), token.getBytes(Charset.forName("UTF-8")),
  205.                     Expiration.from(expire, TimeUnit.MILLISECONDS), RedisStringCommands.SetOption.SET_IF_ABSENT);
  206.             if(result!=null && result)
  207.                 return token;
  208.         }finally {
  209.             RedisConnectionUtils.releaseConnection(conn, factory);
  210.         }
  211.         return null;
  212.     }
  214.     /**
  215.      * 解锁
  216.      * @param name
  217.      * @param token
  218.      * @return
  219.      */
  220.     public boolean unlock(String name, String token) {
  221.         byte[][] keysAndArgs = new byte[2][];
  222.         keysAndArgs[0] = name.getBytes(Charset.forName("UTF-8"));
  223.         keysAndArgs[1] = token.getBytes(Charset.forName("UTF-8"));
  224.         RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
  225.         RedisConnection conn = factory.getConnection();
  226.         try {
  227.             Long result = (Long)conn.scriptingCommands().eval(unlockScript.getBytes(Charset.forName("UTF-8")), ReturnType.INTEGER, 1, keysAndArgs);
  228.             if(result!=null && result>0)
  229.                 return true;
  230.         }finally {
  231.             RedisConnectionUtils.releaseConnection(conn, factory);
  232.         }
  234.         return false;
  235.     }
  236. }
  238. IndexController
  240. package com.cxb.redis;
  242. import org.springframework.beans.factory.annotation.Autowired;
  243. import org.springframework.transaction.annotation.Transactional;
  244. import org.springframework.web.bind.annotation.GetMapping;
  245. import org.springframework.web.bind.annotation.RestController;
  247. @RestController
  248. public class IndexController {
  250.     @Autowired
  251.     private RedisLock redisLock;
  253.     @GetMapping("/")
  254.     @Transactional(rollbackFor = Exception.class)
  255.     public String testLock() {
  256.         String token = null;
  257.         String result = null;
  258.         try {
  259.             token = redisLock.lock("lock_name", 10000, 11000);
  260.             if (token != null) {
  261.                 System.out.println("我拿到了锁哦...");
  262.                 // 执行业务代码
  263.                 Thread.sleep(15000L);
  264.                 result = "我拿到了锁哦, 执行业务代码";
  265.             } else {
  266.                 System.out.println("我没有拿到锁唉...");
  267.                 result = "我没有拿到锁唉";
  268.             }
  269.         }
  270.         catch (Exception e){
  271.             System.out.println("处理业务逻辑报错...");
  272.             result = "处理业务逻辑报错";
  273.         }
  274.         finally {
  275.             if (token != null) {
  276.                 redisLock.unlock("lock_name", token);
  277.                 System.out.println("释放了锁...");
  278.             }
  279.         }
  280.         return result;
  281.     }
  282. }
  284. RedisLockApplication
  286. package com.cxb.redis;
  288. import org.springframework.boot.SpringApplication;
  289. import org.springframework.boot.autoconfigure.SpringBootApplication;
  290. import org.springframework.cache.annotation.EnableCaching;
  292. @SpringBootApplication
  293. @EnableCaching
  294. public class RedisLockApplication {
  296.     public static void main(String[] args) {
  297.         SpringApplication.run(RedisLockApplication.class, args);
  298.     }
  300. }

启动项目测试：这里启动多个实例，先直接run RedisLockApplication 启动实例一

勾选图中所示，然后修改application.properties启动的端口，再run RedisLockApplication 启动实例二

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 1

访问：http://localhost:8082/ 和 http://localhost:8081/

因为处理业务逻辑这里模拟睡眠了15s，看谁先访问，必须等前者处理完之后才会执行后者。

代码下载

参考文件

发表评论

表情：
评论列表 （有 0 条评论，115人围观）

还没有评论，来说两句吧...

相关阅读

    相关 使用redis实现分布式锁

    简介： 当高并发访问某个接口的时候，如果这个接口访问的数据库中的资源，并且你的数据库事务级别是可重复读（Repeatable read）的话，确实是没有线程问题的，因为数

    - 日理万妓- 日理万妓/ 0 赞/ 402 阅读