Redisson 分布式锁使用

原创 已于 2022-06-22 10:03:08 修改 · 806 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #分布式 #java

于 2022-06-19 22:36:51 首次发布
本文介绍了如何使用Redisson实现分布式锁，包括添加依赖、配置、互斥锁、读写锁、计数器和信号量的使用。通过示例代码展示了Redisson在确保线程安全和资源管理方面的功能。
Redis 分布式锁使用

上一篇尝试了对分布式锁实现的思考，发现要实现一把分布式锁并不简单，好在 Redisson 实现了对于分布式锁的要求。本章主要介绍 Redisson 中分布式锁的使用。

添加依赖
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.skystep</groupId>
    <artifactId>lock</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>lock</name>
    <description>lock</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.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.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <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-web</artifactId>
        </dependency>

        <!-- springboot整合redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.13.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.skystep.lock.LockApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
添加配置
spring:
  application:
    name: lock
  redis:
    host: 139.9.189.167
    port: 6379
    password: null
    database: 1
    timeout: 30000

server:
  port: 8080
RedissonConfig实现

RedissonConfig 用于配置 redis 服务器参数，并且将 RedissonClient 注入到 spring 容器中。

package com.skystep.lock.config;

import io.micrometer.core.instrument.util.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    String redisHost;

    @Value("${spring.redis.port}")
    String redisPort;

    @Value("${spring.redis.password}")
    String redisPassword;

    @Value("${spring.redis.timeout}")
    Integer redisTimeout;

    /**
     * Redisson配置
     * @return RedissonClient
     */
    @Bean
    RedissonClient redissonClient() {
        Config config = new Config();

        redisHost = redisHost.startsWith("redis://") ? redisHost : "redis://" + redisHost;
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(redisHost + ":" + redisPort)
                .setTimeout(redisTimeout);

        if (StringUtils.isNotBlank(redisPassword)) {
            serverConfig.setPassword(redisPassword);
        }

        return Redisson.create(config);
    }
}
互斥锁

编写测试类，模拟多线程累计，每个线程将 sum 从0到20000座累加，10个线程得出的结果是200000，对照使用分布式锁和不使用分布式锁的结果。

package com.skystep.lock;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@Slf4j
class LockApplicationTests {
    @Autowired
    RedissonClient redissonClient;

    RLock lock;

    private static int sum = 0;

    private static final int THREAD_CNT = 10;

    private void sum() {
        for (int j = 0; j < 20000; j++) {
            ++sum;
        }
    }

    private void sumLock() {
        lock = redissonClient.getLock("sum-lock");
        lock.lock();
        try {
            for (int j = 0; j < 20000; j++) {
                ++sum;
            }
        } finally {
            lock.unlock();
        }
    }

    @Test
    // 不使用分布式锁测试
    void sumTest() {
        // 创建10个线程对sum进行累计，每个线程加20000，
        Thread[] threads = new Thread[THREAD_CNT];
        for (int k = 0; k < THREAD_CNT; k++) {
            threads[k] = new Thread(this::sum);
            threads[k].start();
        }
        // 等待线程执行完毕
        for (int k = 0; k < THREAD_CNT; k++) {
            try {
                threads[k].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 打印结果，正常应该是200000
        log.info("sum:{}", sum);
    }

    @Test
    // 使用分布式锁测试
    void sumLockTest() {
        // 创建10个线程对sum进行累计，每个线程加20000，
        Thread[] threads = new Thread[THREAD_CNT];
        for (int k = 0; k < THREAD_CNT; k++) {
            threads[k] = new Thread(this::sumLock);
            threads[k].start();
        }
        // 等待线程执行完毕
        for (int k = 0; k < THREAD_CNT; k++) {
            try {
                threads[k].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 打印结果，正常应该是200000
        log.info("sum:{}", sum);
    }
}

运行 sumLockTest 得出结果：

2022-06-19 20:12:08.663  INFO 28036 --- [main] com.skystep.lock.LockApplicationTests    : sum:200000

运行 sumTest 得出结果：

2022-06-19 20:13:12.190  INFO 30600 --- [main] com.skystep.lock.LockApplicationTests    : sum:29750

从两个结果对比，使用分布式锁在多线程环境下，可以保证线程数据安全，保证互斥性。其使用和 Java 工具类 java.util.concurrent 中的 ReentrantLock 相同。

读写锁

如果写锁没完成，就读取不到数据。保证能读到的永远是最新数据。

@SneakyThrows
@Test
public void write() {
    // 获取读写锁
    RReadWriteLock lock = redissonClient.getReadWriteLock("rw-lock");
    RLock rLock = lock.writeLock();
    try {
        rLock.lock();
        Thread.sleep(30000);
        redisTemplate.opsForValue().set("writeValue", 1);
    } finally {
        // 释放锁
        rLock.unlock();
    }
}

@Test
public void read() {
    // 获取读写锁
    RReadWriteLock lock = redissonClient.getReadWriteLock("rw-lock");
    RLock rLock = lock.readLock();
    // 加读锁，写锁没完成，就读不了
    rLock.lock();
    try {
        Integer writeValue = (Integer)redisTemplate.opsForValue().get("writeValue");
        log.info("读锁返回的值：{}", writeValue);
    } finally {
        rLock.unlock();
    }
}

先运行 write 测试，在运行 read 测试，由于 write 函数睡眠 30s，read 函数 也会进入阻塞，直到 write 函数写数据完成，read 函数成功拿到写入的值，从而保证能读到的永远是最新数据。

  • 先加写锁，后加读锁，此时并不会立刻给数据加读锁，而是需要等待写锁释放后，才能加读锁；
  • 先加读锁，再加写锁：有读锁，写锁需要等待；
  • 先加读锁，再加读锁：并发读锁相当于无锁模式，会同时加锁成功；

只要有写锁的存在，都必须等待，写锁是一个排他锁，只能有一个写锁存在，读锁是一个共享锁，可以有多个读锁同时存在。

计数器

开启计数器，只有当计数器数量减少为 0 时，线程才会往下执行。和 java.util.concurrent.CountDownLatch 的使用相同，常用于将异步转化同步。

@Test
public void count() throws InterruptedException {
    RCountDownLatch latch = redissonClient.getCountDownLatch("anyCountDownLatch");
    latch.trySetCount(1);
    latch.await();
}

@Test
public void countDown() {
    RCountDownLatch latch = redissonClient.getCountDownLatch("anyCountDownLatch");
    latch.countDown();
}

先运行 count 函数，当运行到 latch.await() 时线程会进入阻塞状态，再运行 countDown 函数，执行 latch.countDown() 计数器减 1，这是可以看到 count 函数继续执行。

信号量

信号量，可以用来控制同时访问特定资源的线程数量，通过协调各个线程，以保证合理的使用资源。通常用于资源有明确访问数量限制的场景，常用于限流 。比如停车场场景，车位数量有限，同时只能容纳多少台车，车位满了之后只有等里面的车离开停车场外面的车才可以进入。

@Test
public void setCount()  {
    // 设置这个停车场有三个车位
    redisTemplate.opsForValue().set("park",3); 
}

@Test // 占用一个，如果3个都占用了，就锁住，一直等待
public void park() throws InterruptedException {
    RSemaphore park = redissonClient.getSemaphore("park");
    park.acquire();
}

@Test // 释放一个
public void go() throws InterruptedException {
    RSemaphore park = redissonClient.getSemaphore("park");
    park.release(); 
}

先运行 setCount 函数，模拟这个停车场有三个车位，再运行 park 模拟申请车位，由于当前没有释放的车位，会进入阻塞，运行 go 函数，park 放弃阻塞继续运行。

代码地址

如果没有积分可以关注并且私聊我 https://download.youkuaiyun.com/download/skystep/85698350

redisson分布式锁的使用方法
qq_64688685的博客
05-15 739
【代码】redisson分布式锁的使用方法。
Redisson分布式锁使用
haochajin的博客
05-11 2272
一、分布式锁简介 在单进程的系统中，如果服务在运行时只有一个线程在使用，其实是不需要锁的，因为不存在对某个变量同时操作的情况。当存在多个线程同时使用某个变量时，就需要对变量或者代码块进行控制，防止线程之间相互影响。锁的本质可以理解为一种标记，这个标记对于所有的线程都是可见的，当某个线程先拥有这个标记时，同时也就拥有了对变量的读写权利，此时其他的线程都处于等待状态，等待获取标记的线程操作完成后，释放标记，才会轮到下一个线程操作。 说起分布式，就不得不提CAP理论，目前我们的很多服务都是采用多节点部署的，这种情
Redisson 框架使用redis分布式锁
最新发布
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
11-21 354
在 Redis 单实例或哨兵模式下，如果主节点宕机，即使有从节点，也可能因主从异步复制导致锁丢失（客户端A在主节点拿到锁，但锁还未同步到从节点，主节点就宕机了，从节点升级为主后没有这把锁，客户端B又能获取锁）。
Redisson实现分布式锁
m0_52789121的博客
08-02 561
Redis是最流行的NoSQL数据库解决方案之一，而Java是世界上最流行（注意，没有说“最好”）的编程语言之一。虽然两者看起来很自然地在一起“工作”，但是要知道，Redis其实并没有对Java提供原生支持。相反，作为Java开发人员，我们若想在程序中集成Redis，必须使用Redis的第三方库。而Redisson就是用于在Java程序中操作Redis的库，它使得我们可以在程序中轻松地使用Redis。...
Redisson分布式锁的使用
weixin_53244007的博客
04-23 904
Redisson分布式锁的使用
redisson分布式锁的使用
cc890824的博客
09-22 439
【代码】redisson分布式的使用。
基于Java_SpringBoot框架构建的智能数据分析平台项目初始模板_整合Radisson分布式锁与缓存管理_RabbitMQ消息队列实现异步任务处理_集成AIGC技术调用Op.zip
09-26
Radisson正是基于这样的需求应运而生的分布式锁和缓存管理工具，它支持多种部署模式和高可用性特性，非常适合需要高性能和高稳定性的数据分析平台。 消息队列在智能数据分析平台中扮演了不可或缺的角色，尤其是...
Redisson获取/释放分布式锁流程中使用的方法以及watchDog机制相关源码分析
小爽帅到拖网速的博客
01-06 1817
本文通过解读源码的方式详细介绍了通过Redisson获取/释放分布式锁的流程以及执行watchDog机制的过程，充分解读了Redisson如何解决使用redis set nx ex 命令带来的锁不可重入、锁超时释放以及锁误删的问题
redision中锁续期线程是如何知道获取锁的线程结束或崩溃呢？
08-02
引用[^1]提到了Radisson（应为Redisson）的看门狗机制，它类似于AQS的实现（在分布式环境中的实现），通过后台线程来监听锁的状态并续期。 因此，用户的问题得到解答：Redisson通过看门狗线程定期检查持有锁的...
精选资源
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
springboot集成redisson的几种方式
weixin_44186675的博客
12-07 2110
本文主要描述springboot继承redisson的几种方式以及redisson分布式锁的使用；一、redisson简介？Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。Redisson在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的一系列优势，在Java实用工具包中常用接口的基础上，为使用者提供了一系列具有分布式特性的常用工具类。
redisson的分布式锁的使用
码大师的博客
01-09 3617
redisson的使用： 1、引入依赖 <!-- redisson 分布式锁--> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.15.3</version> </dep
Redisson分布式锁的简单使用
热门推荐
阿飞云漫步
04-12 2万+
redis分布式锁学习和集成框架Redisson分布式锁的一些简单使用
【Redisson】Redisson--分布式锁的使用（推荐使用）
DreamSun的博客
05-11 3707
在某些场景中，多个进程必须以互斥的方式独占共享资源，这时用分布式锁是最直接有效的。随着技术快速发展，数据规模增大，分布式系统越来越普及，一个应用往往会部署在多台机器上（多节点），在有些场景中，为了保证数据不重复，要求在同一时刻，同一任务只在一个节点上运行，即保证某一方法同一时刻只能被一个线程执行。
Redisson分布式锁使用详解
2301_76166241的博客
07-24 1712
通常我们都会将redisson实例注入到方法类里面，然后调用加锁方法进行加锁，如果其他业务方法也需要加锁执行，将会产生很多重复代码，由此采用AOP切面的方式，只需要通过注解的方式就能将方法进行加锁处理。自定义注解@InheritedString errorDesc() default "系统正常处理，请稍后提交";切面类实现@Aspect@Component@Autowiredtry {if (!lock) {
使用redisson提供分布式锁
qq_47155894的博客
11-20 2750
Redisson提供的分布式锁
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值