SpringBoot集成redis（2）|（redisTemplate+lua方式实现分布式锁）

客官°小女子只卖身不卖艺 2023-10-03 20:27 8阅读 0赞

## SpringBoot集成redis（2）|（redisTemplate+lua方式实现分布式锁） ##

--------------------

### 文章目录  SpringBoot集成redis（2）|（redisTemplate+lua方式实现分布式锁）  @\[TOC\]  前言  一、redis分布式锁是什么？  二、集成步骤  1.依赖引入  2.文件配置  3.定义redisKey的规则  4.redis分布式锁实现  5.存在的缺点  总结 ###

章节

## 前言 ##

本章节主要介绍SpringBoot项目集成Redis的一些相关知识，主要介绍的是基于Springboot自带的redisTemplate方式，实现在分布式场景下锁机制。

## 一、redis分布式锁是什么？ ##

Redis 分布式锁指的是，所有服务中的所有线程都去获得同一把锁，但只有一个线程可以成功的获得锁，其他没有获得锁的线程必须全部等待，等到获得锁的线程释放掉锁之后获得了锁才能进行操作。Redis官网中，set key value有个带有NX参数的命令，这是一个原子性加锁的命令，指的是此key没有被lock时当前线程才能加锁，如果已经被占用，就不能加锁。

## 二、集成步骤 ##

### 1.依赖引入 ###

> pom依赖如下，主要列出SpringBoot依赖版本以及Redis版本，其他需要依赖自行添加

<parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>2.5.7</version>
          <relativePath/>
      </parent>
      
      
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
          <version>2.6.1</version>
      </dependency>

### 2.文件配置 ###

> yml配置,配置了单机模式、哨兵模式、集群模式

spring:
      redis:
        host: 127.0.0.1
        port: 6379
        password: redis
        timeout: 30000
        database: 1
    #哨兵配
    #    sentinel:
    #      master: mymaster
    #      nodes: 127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381
    #集群配置
    #    cluster:
    #      max-redirects: 100
    #      nodes: 127.0.0.1:6379,127.0.0.1:6380,127.0.0.1:6381,127.0.0.1:6382,127.0.0.1:6383,127.0.0.1:6384

### 3.定义redisKey的规则 ###

> 定义redis存储数据key的规则，key类似于给redis数据进行存储划分，通过建立规范的key可以很好的维护redis数据的，呈现出问题的时候也方便排查，

/**
     * Created by Oak on 2022/1/13.
     * Description: 定义redis中key规则
     * {项目名称}：{模块/_描述/}：/{参数}/    value
     */
    public class RedisKey {
        
    
        public static final String PREFIX ="explo:";
        public static final String TEST =PREFIX+"test:%s";
        public static final String USER =PREFIX+"user:%s";
        //存储商品信息key
        public static final String GOODS =PREFIX+"good:count";
        public static final String GOODSLOCK =PREFIX+"good:lock";
        public static String keyFormate(String template,String keyword){
        
            return String.format(template, keyword);
        }
    }

--------------------

### 4.redis分布式锁实现 ###

> 共享数据设置了商品的数量，现在需要对该商品进行秒杀，首先会获取一个uuid来表示当前操作对象，然后获取redis锁，获取到了后就去减库存，没有这直接返回。减完库存后释放该锁。其他线程即可继续获取该锁来进行抢占商品。

package com.oak.net.rest.controller;
    
    import com.oak.net.redis.RedisKey;
    import com.oak.net.response.ResponseHandle;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.Arrays;
    import java.util.UUID;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Created by Oak on 2022/9/20.
     * Description:
     */
    @Api(tags = {
        "分布式锁接口"})
    @RestController
    @RequestMapping("/lock")
    @Slf4j
    public class LockCtrl {
        
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
    
        @ApiOperation(value = "初始化商品数据", notes = "初始化商品数据")
        @PostMapping(value = "/init")
        public ResponseHandle init(@RequestParam int count) {
        
            redisTemplate.opsForValue().set(RedisKey.GOODS, count, 24,  TimeUnit.HOURS);
            return ResponseHandle.SUCCESS();
        }
    
        /**
         * 共享数据操作，确保同时只能有一个线程执行该操作
         * @return
         */
        private Integer LessQuantity() {
        
    
            int sum = (int)redisTemplate.opsForValue().get(RedisKey.GOODS);
            if (sum > 0) {
        
                int realSum = sum - 1;
                redisTemplate.opsForValue().set(RedisKey.GOODS, realSum);
                System.out.println("A服务-下单成功，数量还剩：" + realSum);
                return realSum;
            } else if (sum == 0) {
        
                System.out.println("A服务-下单失败");
                return 0;
            }
            return null;
        }
    
    
        /**
         * Redis分布式锁
         *
         * @return
         */
        @ApiOperation(value = "Redis锁抢占库存", notes = "Redis锁抢占库存")
        @GetMapping(value = "/order")
        public void order() {
        
            String lockId = UUID.randomUUID().toString().replaceAll("-", "");
            Integer integer ;
            Boolean boo = false;
            try {
        
                boo = redisTemplate.opsForValue().setIfAbsent(RedisKey.GOODSLOCK, lockId, 1000, TimeUnit.MILLISECONDS);
                if (boo) {
        
                    integer = LessQuantity();
                    log.info("商品下单成功，还有：{}",integer);
                }
            } catch (Exception e) {
        
                log.error("商品下单异常");
            } finally {
        
                if (!boo) {
        
                    log.info("没有获取到锁：{}", lockId);
                } else {
        
                    Long execute = redisTemplate.execute(getScript(), Arrays.asList(RedisKey.GOODSLOCK), lockId);
                    if (execute.longValue() == 0) {
        
                        log.info("释放锁{}失败:{}", lockId,execute);
                    } else if (execute.longValue() == 1) {
        
                        log.info("释放锁{}成功:{}", lockId,execute);
                    }
                }
            }
    
        }
    
        /**
         * 封装redisTemplate 执行的lua脚本
         * @return
         */
        private DefaultRedisScript<Long> getScript() {
        
            String script = "if redis.call('get',KEYS[1]) == ARGV[1]\n" +
                    "then\n" +
                    "return redis.call('del',KEYS[1])\n" +
                    "else\n" +
                    "   return 0\n" +
                    "end";
            DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>();
            defaultRedisScript.setResultType(Long.class);
            defaultRedisScript.setScriptText(script);
            return defaultRedisScript;
        }
    }

--------------------

### 5.存在的缺点 ###

> 问题：「锁过期释放了，业务还没执行完」。假设线程a获取锁成功，一直在执行临界区的代码。但是时间过去后，它还没执行完。但是，这时候锁已经过期了，此时线程b又请求过来。显然线程b就可以获得锁成功，也开始执行临界区的代码。那么问题就来了，临界区的业务代码都不是严格串行执行。

> 解决方式1：修改过期时间，过期时间设置大一点，使得业务逻辑能在正常范围内执行完成，这样存在风险，且浪费资源

> 解决方式2：使用Redisson方式解决，线程一加锁成功，就会启动一个watch dog看门狗，它是一个后台线程，会每隔10秒检查一下，如果线程1还持有锁，那么就会不断的延长锁key的生存时间。因此，Redisson就是使用Redisson解决了「锁过期释放，业务没执行完」问题，该种方案将会在下期代码实现

--------------------

## 总结 ##

以上就是SpringBoot集成redis使用redisTemplate+lua实现分布式锁的代码，目前存在的问题也是通常分布式锁普遍存在的问题，后面将介绍开源Redisson解决该问题的方式。