SpringBoot整合Redis【三】Redisson实现分布式锁

介绍

分布式锁：指的是在某种高并发的业务情况下，保证数据一致性的锁，如：秒杀业务往往是高并发的，那么就有可能导致超卖的情况发生，此时就可以使用分布式锁来保证商品不会超卖

原理

具体原理是使用Redis缓存实现分布式锁，当大量用户请求资源时，保证资源的同步性，如上面的秒杀例子里，当用户请求时库存就要减一，此时我们就要保证高并发情况下，库存资源的同步访问

注意分布式锁要存在统一的Redis缓存中，各服务统一访问该缓存获取锁访问共享资源

Redisson实现分布式锁的原理

案例

实现逻辑：先往Redis写入库存数据

具体参考：

SpringBoot操作Redis 一

SpringBoot操作Redis 二

@GetMapping("/miaosha/add")
public String miaoshaAdd() {

    String key = "product:0";

    redisUtil.set(key, "100");

    return "miaosha add success";
}

ApiFox发送请求

Redis Desktop Manager查看数据，库存为100个

有了库存后，我们就可以模拟秒杀场景了，代码如下：

POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redis</name>
    <description>redis</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.16.8</version>
        </dependency>

        <!--jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

        <!--common-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.2</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-core</artifactId>
            <version>5.3.10</version>
        </dependency>

        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.69</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Yml

redis:
  db: 0
  host: 192.168.61.4
  port: 6379
  password: psd
  timeout: 3000
  max-active: 100
  max-idle: 10
  min-idle: 10
  max-wait: 20000

server:
  port: 80

spring: # 允许循环依赖
  main:
    allow-circular-references: true

核心：通过Redisson的getLock方法生成的RLock对象的lock与unlock方法同步代码逻辑，这里的锁理论上来说是从Redis中查的，如果不存在就生成，一个共享资源对应唯一一个锁，各服务（线程）抢这把锁进行业务处理

package com.example.redis.controller;

import com.example.redis.config.R;
import com.example.redis.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @description: miaosha
 * @author: zj
 * @date: 2022-07-27 17:21
 */
@RestController
@Slf4j
public class MiaoShaController {

    @Resource
    private RedissonClient redission;

    @Resource
    private RedisUtil redisUtil;

    @GetMapping("/miaosha")
    public String miaosha() {
        String key = "key:product";

        RLock lock = redission.getLock(key);
        lock.lock();

        try {
            //减库存
            int stock = Integer.parseInt(redisUtil.get("product:0"));
            if (stock > 0) {
                redisUtil.decrby("product:0", 1);
                System.out.println("扣减成功，剩余库存:" + redisUtil.get("product:0"));
            } else {
                return R.ok("stock is empty");
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }

        lock.unlock();
        return R.ok("success");
    }


    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.61.4:6379").setDatabase(0).setPassword("psd");
        return Redisson.create(config);
    }


}

ApiFox模拟高并发访问接口测试用例，生成100个线程循环10次，模拟高并发接口请求

可以看到控制台是一个一个进行资源消费的，这样就实现了使用Redis的分布式锁

Redis里的数据也被消费完了