使用 Redisson 框架基于 Redis 实现分布式锁

标签：Redisson Redis redis springframework result org stock redisTemplate 分布式

分布式锁可以采用数据库、zookeeper、redis 三种方式实现。

采用数据库实现方式，主要采用表字段的唯一索引特性。数据库是非常昂贵的资源，非常不推荐，最致命就是性能，不要去增加不必要的负担。

采用 zookeeper 的实现方式，主要使用其为客户端创建临时有序节点的特性，在我之前的博客有介绍。虽然使用 Apache Curator 客户端框架可以简化操作，但是其底层实现比较复杂，总体而言性能相对较差，因为需要维护大量的 Zookeeper 状态，引起大量网络 IO 的开销。

采用 redis 的实现方式，主要采用其单线程执行相关命令的特性。实现原理非常简单，性能也是最好，尤其采用 Redisson 实现方案。

Redisson 是基于 Redis 实现的一个框架。充分的利用了 Redis 键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包，获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度，简化了分布式环境中程序相互之间的协作。Redisson已经内置提供了基于Redis的分布式锁实现，此种方式是我们推荐的分布式锁使用方式。

本篇博客介绍 redis 的两种分布式锁的实现方式：自己编码实现方式和采用 redisson 框架的实现方式，在博客的最后会提供源代码下载。

Redisson 的官网访问地址为：https://redisson.org

一、搭建工程

新建一个 springboot 工程，取名为 springboot_redisson，工程结构如下图所示：

首先查看一下 pom 文件的内容，主要是引入了 redis 和 redisson 的 starter 依赖包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jobs</groupId>
    <artifactId>springboot_redisson</artifactId>
    <version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--引入 redis 的 starter 依赖包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--引入 redisson 的 starter 依赖包-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.30.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.5</version>
            </plugin>
        </plugins>
    </build>
</project>

然后查看一下 application.yml 的配置内容，主要是 redis 的连接信息配置

server:
  port: 8888
spring:
  redis:
    host: 192.168.136.128
    port: 6379
    password: root
    jedis:
      pool:
        # 最大连接数
        max-active: 10
        # 最大空闲连接数
        max-idle: 5
        # 最小空闲
        min-idle: 1
        # 连接超时时间（毫秒）
        max-wait: 3000

二、代码细节

如果使用 RedisTemplate 操作 redis 的话，需要编写一个配置类，主要是改变一下 key 的序列化方式，方便明文查看

package com.jobs.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        //默认的Key序列化器为：JdkSerializationRedisSerializer
        //这里只是将 key 采用 string 序列化，方便查看
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }
}

最后就是编写一个 controller 类，里面有 redis 和 redisson 两种实现分布式锁的方案

package com.jobs.controller;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/lock")
public class LockController {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 使用 redis 的两个命令实现分布式加锁和解锁
     * 加锁：set lock_key lock_value NX PX 3000
     * 解锁：del lock_key
     * 该分布式锁方案，是由我们自己编写代码实现，可以简单的实现分布式锁的特性，
     * 主要的不足时：这里是非阻塞锁，没有重试机制，获取不到锁后，直接返回失败，不太符合大多数应用场景
     */
    @GetMapping("/redistest")
    public String stock1() {
        String result;
        //获取当前线程的id
        String threadId = String.valueOf(Thread.currentThread().getId());
        //尝试加锁，如果获取锁成功，则返回 true
        //为了防止死锁，获取到锁之后，给锁设置了一个 3 秒的有效期，过期自动释放锁
        //key 可以随便定义，value 是线程id
        Boolean locked = redisTemplate.opsForValue().setIfAbsent("mylock", threadId, 3, TimeUnit.SECONDS);
        if (locked) {
            try {
                //由于是 demo，这里就不从数据库中获取库存量了，以 redis 代替数据库获取库存量
                String temp = redisTemplate.opsForValue().get("stock");
                if (StringUtils.hasText(temp)) {
                    int stock = Integer.parseInt(temp);
                    if (stock > 0) {
                        stock--;
                        redisTemplate.opsForValue().set("stock", String.valueOf(stock));
                        result = "库存量扣减成功，剩余库存量：" + stock;
                        System.out.println(result);
                    } else {
                        result = "库存不足!!!";
                        System.out.println(result);
                    }
                } else {
                    result = "请提前在 redis 中设置好 stock 库存量的值";
                    System.out.println(result);
                }
            } catch (Exception ex) {
                result = ex.getMessage();
                System.out.println(result);
            } finally {
                //对比 redis 中的 value 值，如果是当前线程 id 才可以进行解锁
                String myValue = redisTemplate.opsForValue().get("mylock");
                if (threadId.equals(myValue)) {
                    redisTemplate.delete("mylock");
                }
            }
        } else {
            result = "没有获取到锁，不能扣减库存量!!!";
            System.out.println(result);
        }

        return result;
    }

    //--------------------------------------------------

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 使用 Redission 框架实现分布式锁功能，具有阻塞重试的特性，非常适合绝大多数应用场景。
     */
    @GetMapping("/redissontest")
    public String stock2() {
        String result;
        //获得分布式锁对象，这里还没有尝试去获取锁
        RLock lock = redissonClient.getLock("mylock");

        //尝试获取锁，如果获取成功，则后续程序继续执行；如果获取不成功则阻塞等待
        //如果获取锁成功，则锁的有效期是 3 秒，超时后自动解锁
        lock.lock(3, TimeUnit.SECONDS);

        try {
            //由于是 demo，这里就不从数据库中获取库存量了，以 redis 代替数据库获取库存量
            String temp = redisTemplate.opsForValue().get("stock");
            if (StringUtils.hasText(temp)) {
                int stock = Integer.parseInt(temp);
                if (stock > 0) {
                    stock--;
                    redisTemplate.opsForValue().set("stock", String.valueOf(stock));
                    result = "库存量扣减成功，剩余库存量：" + stock;
                    System.out.println(result);
                } else {
                    result = "库存不足!!!";
                    System.out.println(result);
                }
            } else {
                result = "请提前在 redis 中设置好 stock 库存量的值";
                System.out.println(result);
            }
        } catch (Exception ex) {
            result = ex.getMessage();
            System.out.println(result);
        } finally {
            //解锁
            lock.unlock();
        }

        return result;
    }
}

代码已经编写完毕，注释也比较详细，应该很容易理解。可以打包后部署多份，采用 nginx 进行负载均衡转发，然后采用 Jmeter 等压力测试工具，模拟出多线程进行访问请求，测试分布式锁的实现结果。这里就不进行展示了。

本篇博客的源代码下载地址为：https://files.cnblogs.com/files/blogs/699532/springboot_redisson.zip

标签：Redisson,Redis,redis,springframework,result,org,stock,redisTemplate,分布式
From： https://www.cnblogs.com/studyjobs/p/18187085

使用 Redisson 框架基于 Redis 实现分布式锁

一、搭建工程

二、代码细节

相关文章

赞助商

阅读排行