ASCII码 ASCII码

SpringBoot基于Redis的分布式锁实现过程记录

发布于：2022-01-09 12:15:02  栏目：技术文档

一、概述分布式锁的重要性不言而喻，原因不在赘述，每一位菜鸟都有理由掌握它。提到分布式锁，解决方案更是乌泱乌泱的，如：

直接通过关系型数据库实现基于Redission实现基于Apache Curator实现…本文暂时先介绍一种，基于Redission实现的方式

二、环境搭建有一个简单的SpringBoot环境即可，便于测试：

依赖

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.6.5</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies>配置server: port: 7077

spring: redis: host: 192.144.228.170 database: 01234567启动及配置类package com.ideax.distributed;

import org.redisson.Redisson;import org.redisson.api.RedissonClient;import org.redisson.config.Config;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.Bean;

Java技术迷

@SpringBootApplicationpublic class DistributedApplication { public static void main(String[] args) { SpringApplication.run(DistributedApplication.class,args); }

  1. /**
  2.  * 配置redisson客户端
  3.  * @return org.redisson.Redisson
  4.  * @author zhangxs
  5.  * @date 2022-01-06 10:01
  6.  */
  7. @Bean
  8. public Redisson redisson(){
  9.     // 单机模式
  10.     Config config = new Config();
  11.     config.useSingleServer().setAddress("redis://192.144.228.170:6379").setDatabase(0);
  12.     return (Redisson) Redisson.create(config);
  13. }

}1234567891011121314151617181920212223242526272829三、模拟一个库存扣减的场景package com.ideax.distributed.controller;

import org.redisson.Redisson;import org.redisson.api.RLock;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.StringRedisTemplate;import org.springframework.http.ResponseEntity;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;

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

/**

  • 库存 前端控制器
  • @author zhangxs

  • @date 2022-01-06 09:46*/@RequestMapping(“/inventory”)@RestControllerpublic class InventoryController { @Autowired private StringRedisTemplate redisTemplate;

    @Autowired private Redisson redisson;

    @GetMapping(“/minus”) public ResponseEntity<String> minusInventory(){

    1.  // 分布式高并发场景下，这样肯定不行
    2.  synchronized (this) {
    3.      int stock = Integer.parseInt(Objects.requireNonNull(redisTemplate.opsForValue().get("stock")));
    4.      if (stock > 0) {
    5.          int currentStock = stock - 1;
    6.          redisTemplate.opsForValue().set("stock", currentStock + "");
    7.          System.out.println("扣减成功，当前库存为" + currentStock);
    8.      } else {
    9.          System.out.println("库存不足，扣减失败！");
    10.      }
    11.  }
    12.  return ResponseEntity.ok("success");

    }

    @GetMapping(“/minus1”) public ResponseEntity<String> minusInventory1(){

    1.  // 相当于setnx命令
    2.  String lockKey = "lockKey";
    3.  // 务必加try-finally，因为如果服务挂了，锁还得释放
    4.  String clientId = UUID.randomUUID().toString();
    5.  try {
    6.      // 相当于加锁
    7.      // Boolean absent = redisTemplate.opsForValue().setIfAbsent(lockKey, "zxs");
    8.      // 上下两行不能分开写，如果这中间报异常了，依然出现死锁
    9.      // redisTemplate.expire(lockKey,10, TimeUnit.SECONDS);
    10.      Boolean absent = redisTemplate.opsForValue().setIfAbsent(lockKey, clientId,30,TimeUnit.SECONDS);
    11.      if (!absent) {
    12.          return ResponseEntity.notFound().build();
    13.      }
  1.         int stock = Integer.parseInt(Objects.requireNonNull(redisTemplate.opsForValue().get("stock")));
  2.         if (stock > 0) {
  3.             int currentStock = stock - 1;
  4.             redisTemplate.opsForValue().set("stock", currentStock + "");
  5.             System.out.println("扣减成功，当前库存为" + currentStock);
  6.         } else {
  7.             System.out.println("库存不足，扣减失败！");
  8.         }
  9.     } finally {
  10.         // 如果系统挂了呢，finally也不起作用了，因此还需要设置超时时间
  11.         // 释放锁之前，判断一下，务必释放的锁是自己持有的锁
  12.         if (clientId.equals(redisTemplate.opsForValue().get(lockKey))) {
  13.             redisTemplate.delete(lockKey);
  14.         }
  15.     }
  16.     return ResponseEntity.ok("success");
  17. }
  21. /**
  22.  * 终极方案
  23.  */
  24. @GetMapping("/minus2")
  25. public ResponseEntity<String> minusInventory2(){
  26.     // redisson解决方案
  27.     String lockKey = "lockKey";
  28.     RLock lock = redisson.getLock(lockKey);
  29.     try {
  30.         // 加锁
  31.         lock.lock();
  32.         int stock = Integer.parseInt(Objects.requireNonNull(redisTemplate.opsForValue().get("stock")));
  33.         if (stock > 0) {
  34.             int currentStock = stock - 1;
  35.             redisTemplate.opsForValue().set("stock", currentStock + "");
  36.             System.out.println("扣减成功，当前库存为" + currentStock);
  37.         } else {
  38.             System.out.println("库存不足，扣减失败！");
  39.         }
  40.     } finally {
  41.         // 释放锁
  42.         lock.unlock();
  43.     }
  44.     return ResponseEntity.ok("success");
  45. }

}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105四、总结@GetMapping(“/minus”) public ResponseEntity<String> minusInventory()：初步实现方式，在单线程环境下可以使用，但是在分布式高并发场景下，毫无疑问是肯定不行的@GetMapping(“/minus1”) public ResponseEntity<String> minusInventory1()：进阶实现方式，在一般的不拘小节的公司，勉强够用，但是你需要考虑一下，锁过期时间，到底设置多少才能完美呢？@GetMapping(“/minus2”) public ResponseEntity<String> minusInventory2()：终极实现方式，redisson帮我们解决了上面的实现方式出现的尴尬情况

相关推荐
阅读 +

© 2020 asciim码

人生就是一场修行