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

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

---

章节

前言

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

一、redis分布式锁是什么？

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

二、集成步骤

1.依赖引入

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

  <!-- Springboot 版本 -->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.5.7</version>
      <relativePath/>
  </parent>
  
  <!-- redis依赖 -->
  <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解决该问题的方式。