浅谈Redisson实现分布式锁的原理

news2024/11/26 12:40:55

1.Redisson简介

Redis 是最流行的 NoSQL 数据库解决方案之一，而 Java 是世界上最流行（注意，我没有说“最好”）的编程语言之一。虽然两者看起来很自然地在一起“工作”，但是要知道，Redis 其实并没有对 Java 提供原生支持。

相反，作为 Java 开发人员，我们若想在程序中集成 Redis，必须使用 Redis 的第三方库。而 Redisson 就是用于在 Java 程序中操作 Redis 的库，它使得我们可以在程序中轻松地使用 Redis。Redisson 在 java.util 中常用接口的基础上，为我们提供了一系列具有分布式特性的工具类。

Redisson底层采用的是Netty 框架。支持Redis 2.8以上版本，支持Java1.6+以上版本。

2.Redisson实现分布式锁的步骤

2.1.引入依赖

引入重要的两个依赖，一个是spring-boot-starter-data-redis，一个是redisson：

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

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.7.5</version>
</dependency>

2.2.application.properties

# Redis服务器地址（默认session使用）
spring.redis.host=127.0.0.1
# Redis服务器连接密码（默认为空）
# spring.redis.password=
# Redis服务器连接端口
spring.redis.port=6379

2.3.定义Loker

接口编程的思想还是要保持的。我们定义一个Loker接口，用于分布式锁的一些操作：

package com.bruceliu.lock;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.lock
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:20
 * @Description: 锁接口
 */
import java.util.concurrent.TimeUnit;

public interface Locker {

    /**
     * 获取锁，如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
     *
     * @param lockKey
     */
    void lock(String lockKey);

    /**
     * 释放锁
     *
     * @param lockKey
     */
    void unlock(String lockKey);

    /**
     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey
     * @param timeout
     */
    void lock(String lockKey, int timeout);

    /**
     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey
     * @param unit
     * @param timeout
     */
    void lock(String lockKey, TimeUnit unit, int timeout);

    /**
     * 尝试获取锁，获取到立即返回true,未获取到立即返回false
     *
     * @param lockKey
     * @return
     */
    boolean tryLock(String lockKey);

    /**
     * 尝试获取锁，在等待时间内获取到锁则返回true,否则返回false,如果获取到锁，则要么执行完后程序释放锁，
     * 要么在给定的超时时间leaseTime后释放锁
     *
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     */
    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
            throws InterruptedException;

    /**
     * 锁是否被任意一个线程锁持有
     *
     * @param lockKey
     * @return
     */
    boolean isLocked(String lockKey);
}

有了Locker接口，我们再添加一个基于Redisson的实现类RedissonLocker，实现Locker中的方法：

package com.bruceliu.lock;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.lock
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:20
 * @Description: 基于Redisson的分布式锁
 */
import java.util.concurrent.TimeUnit;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class RedissonLocker implements Locker {

    private RedissonClient redissonClient;

    public RedissonLocker(RedissonClient redissonClient) {
        super();
        this.redissonClient = redissonClient;
    }

    @Override
    public void lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    @Override
    public void lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
    }

    @Override
    public void lock(String lockKey, TimeUnit unit, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    @Override
    public boolean tryLock(String lockKey, long waitTime, long leaseTime,
                           TimeUnit unit) throws InterruptedException{
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock(waitTime, leaseTime, unit);
    }

    @Override
    public boolean isLocked(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isLocked();
    }

}

2.4.定义工具类

有了Locker和实现类RedissonLocker，我们总不能一直去创建RedissonLocker对象或者不断的在每个要使用到分布式锁的地方都注入RedissonLocker的对象，所以我们定义一个工具类LockUtil，到时候想哪里使用就直接使用工具类的静态方法就行了：

package com.bruceliu.utils;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.utils
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:21
 * @Description: TODO
 */
import com.bruceliu.lock.Locker;

import java.util.concurrent.TimeUnit;

/**
 * redis分布式锁工具类
 *
 */
public final class LockUtil {

    private static Locker locker;

    /**
     * 设置工具类使用的locker
     * @param locker
     */
    public static void setLocker(Locker locker) {
        LockUtil.locker = locker;
    }

    /**
     * 获取锁
     * @param lockKey
     */
    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    /**
     * 释放锁
     * @param lockKey
     */
    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    /**
     * 获取锁，超时释放
     * @param lockKey
     * @param timeout
     */
    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    /**
     * 获取锁，超时释放，指定时间单位
     * @param lockKey
     * @param unit
     * @param timeout
     */
    public static void lock(String lockKey, TimeUnit unit, int timeout) {
        locker.lock(lockKey, unit, timeout);
    }

    /**
     * 尝试获取锁，获取到立即返回true,获取失败立即返回false
     * @param lockKey
     * @return
     */
    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    /**
     * 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     * @throws InterruptedException
     */
    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) throws InterruptedException {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    /**
     * 锁释放被任意一个线程持有
     * @param lockKey
     * @return
     */
    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }
}

2.5.Redisson的配置类

现在我们开始配置吧，创建一个redisson的配置类RedissonConfig，内容如下：

package com.bruceliu.config;

import java.io.IOException;

import com.bruceliu.lock.RedissonLocker;
import com.bruceliu.utils.LockUtil;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.config
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:22
 * @Description: TODO
 */
@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}")
    private String host;

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

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

    /**
     * RedissonClient,单机模式
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        Config config = new Config();
        //config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        return Redisson.create(config);
    }

    @Bean
    public RedissonLocker redissonLocker(RedissonClient redissonClient){
        RedissonLocker locker = new RedissonLocker(redissonClient);
        //设置LockUtil的锁处理对象
        LockUtil.setLocker(locker);
        return locker;
    }
}

2.6.Redisson分布式锁业务类

package com.bruceliu.service;

import com.bruceliu.utils.LockUtil;

import java.util.concurrent.TimeUnit;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.service
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:26
 * @Description: TODO
 */
public class SkillService {

    int n = 500;

    public void seckill() {
        //加锁
        LockUtil.lock("resource", TimeUnit.SECONDS,5000);
        try {
            System.out.println(Thread.currentThread().getName() + "获得了锁");
            Thread.sleep(3000);
            System.out.println(--n);
        } catch (Exception e) {
            //异常处理
        }finally{
            //释放锁
            LockUtil.unlock("resource");
            System.out.println(Thread.currentThread().getName() + "释放了锁");
        }
    }
}

2.7.Redisson分布式锁测试

package com.bruceliu.test;

import com.bruceliu.App;
import com.bruceliu.service.SkillService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.test
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:29
 * @Description: TODO
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class TestLock {

    @Test
    public void testLock() throws Exception{
        SkillService service = new SkillService();
        for (int i = 0; i < 10; i++) {
            ThreadA threadA = new ThreadA(service);
            threadA.setName("ThreadNameA->"+i);
            threadA.start();
        }
        Thread.sleep(50000);
    }

}

class ThreadA extends Thread {

    private SkillService skillService;

    public ThreadA(SkillService skillService) {
        this.skillService = skillService;
    }

    @Override
    public void run() {
        skillService.seckill();
    }
}

运行结果:

注释文中加锁代码：

public void seckill() {
    //加锁
    //LockUtil.lock("resource", TimeUnit.SECONDS,5000);
    try {
        System.out.println(Thread.currentThread().getName() + "获得了锁");
        Thread.sleep(3000);
        System.out.println(--n);
    } catch (Exception e) {
        //异常处理
    }finally{
        //释放锁
        //LockUtil.unlock("resource");
        System.out.println(Thread.currentThread().getName() + "释放了锁");
    }
}

运行结果：
在这里插入图片描述
可以看到存在并发的问题！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/364963.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

windows共享文件夹（目录）（SMB服务）

windows共享文件夹（目录）（SMB服务）

SMB服务&#xff0c;文件共享服务&#xff0c;俗称文件夹&#xff08;目录&#xff09;、打印机等共享 一、创建共享用户 windos系统中&#xff0c;文件夹共享需要设置指定用户与密码&#xff0c;通过输入用户和密码进行连接&#xff0c;在设置共享时系统中有Everyone所有人设…
阅读更多...
【Linux学习笔记】1.Linux 简介及安装

【Linux学习笔记】1.Linux 简介及安装

前言 本章介绍Linux及其安装方法。 Linux 简介 Linux 内核最初只是由芬兰人林纳斯托瓦兹&#xff08;Linus Torvalds&#xff09;在赫尔辛基大学上学时出于个人爱好而编写的。 Linux 是一套免费使用和自由传播的类 Unix 操作系统&#xff0c;是一个基于 POSIX 和 UNIX 的多…
阅读更多...
【基础语法】JavaScript 全栈体系（四）

【基础语法】JavaScript 全栈体系（四）

JavaScript 基础 第五章 类型转换 一、为什么需要类型转换&#xff1f; JavaScript是弱数据类型&#xff1a; JavaScript也不知道变量到底属于那种数据类型&#xff0c;只有赋值了才清楚。 坑&#xff1a; 使用表单、prompt 获取过来的数据默认是字符串类型的&#xff0c;此…
阅读更多...
JVM及其内存模型

JVM及其内存模型

目录儿一、JVM1.1 为什么需要JVM&#xff1f;1.2 JVM内存模型1.3 堆&#xff08;Heap&#xff09;1.4 方法区&#xff08;Method Area&#xff09;1.5 虚拟机栈(JVM Stack)1.6 本地方法栈(Native Stack)1.7 程序计数器&#xff08;PC Register&#xff09;一、JVM JVM是Java V…
阅读更多...
I-Cache 和 D-Cache

I-Cache 和 D-Cache

定义ICache和DCache是一种内存&#xff0c;虽然目前接触了好几种内存&#xff0c;寄存器&#xff0c;DDR等&#xff0c;它们在物理上的工作原理虽然不同&#xff0c;但是访问属性却很像。在速度上CPU > 寄存器 > Cache > SRAM　&#xff1e;&#xff30;&#xff33;&…
阅读更多...
100种思维模型之六顶帽思维模型-018

100种思维模型之六顶帽思维模型-018

工作中&#xff0c;经常开会&#xff0c;开会于工作当然无可厚非。 可是&#xff0c;现实中的会议&#xff0c;往往存在效率低&#xff0c;效果不佳的问题。如&#xff0c;连续开一天的研究讨论会&#xff0c;最后没能讨论出个所以然&#xff0c;又或者会议有了决策&#xff0c…
阅读更多...
QT_dbus(ipc进程间通讯)

QT_dbus(ipc进程间通讯)

QT_dbus(ipc进程间通讯) 前言&#xff1a; 参考链接&#xff1a; https://www.cnblogs.com/brt3/p/9614899.html https://blog.csdn.net/weixin_43246170/article/details/120994311 https://blog.csdn.net/kchmmd/article/details/118605315 一个大型项目可能需要多个子程序同…
阅读更多...
《计算机网络：自顶向下方法》实验5：ARP协议分析 Wireshark实验

《计算机网络：自顶向下方法》实验5：ARP协议分析 Wireshark实验

实验13：ARP协议分析 1 What is the 48-bit Ethernet address of your computer? 00:d0:59:a9:3d:68 2 What is the 48-bit destination address in the Ethernet frame? Is this the Ethernet address of gaia.cs.umass.edu? (Hint: the answer is no). What device has …
阅读更多...
推荐算法—widedeep原理知识总结代码实现

推荐算法—widedeep原理知识总结代码实现

wide&deep原理知识总结代码实现1. Wide&Deep 模型的结构1.1 模型的记忆能力1.2 模型的泛化能力2. Wide&Deep 模型的应用场景3. Wide&Deep 模型的代码实现3.1 tensorflow实现3.2 pytorch实现今天&#xff0c;总结一个在业界有着巨大影响力的推荐模型&#xff0c…
阅读更多...
设计模式.工厂模式.黑马跟学笔记

设计模式.工厂模式.黑马跟学笔记

设计模式.工厂模式4.创建型模式4.2 工厂模式4.2.1 概述4.2.2 简单工厂模式4.2.2.1 结构4.2.2.2 实现4.2.2.4 优缺点4.2.2.3 扩展4.2.3 工厂方法模式4.2.3.1 概念4.2.3.2 结构4.2.3.3 实现4.2.3.4 优缺点4.2.4 抽象工厂模式4.2.4.1 概念4.2.4.2 结构4.2.4.2 实现4.2.4.3 优缺点4…
阅读更多...
C语言进阶（六）—— 结构体

C语言进阶（六）—— 结构体

1. 结构体基础知识1.1 结构体类型的定义struct Person{char name[64];int age; };typedef struct _PERSON{char name[64];int age; }Person;注意&#xff1a;定义结构体类型时不要直接给成员赋值&#xff0c;结构体只是一个类型&#xff0c;编译器还没有为其分配空间&#xff0…
阅读更多...
【Kubernetes 入门实战课】Day02——初识容器

【Kubernetes 入门实战课】Day02——初识容器

系列文章目录 【Kubernetes 入门实战课】Day01——搭建kubernetes实验环境(一) 文章目录系列文章目录前言一、Docker的诞生二、Docker的形态1、Docker Desktop2、Docker Engine二、Docker的安装1、服务器连接外网安装2、服务器不通外网三、Docker的使用三、Docker的架构总结前…
阅读更多...
JavaWeb11-死锁

JavaWeb11-死锁

目录 1.死锁定义 1.1.代码演示 1.2.使用jconsole/jvisualvm/jmc查看死锁 ①使用jconsole&#xff1a;最简单。 ②使用jvisualvm&#xff1a;&#xff08;Java虚拟机&#xff09;更方便&#xff0c;更直观&#xff0c;更智能&#xff0c;更高级&#xff0c;是合适的选择。 …
阅读更多...
Melis4.0[D1s]:2.启动流程（GUI桌面加载部分）跟踪笔记

Melis4.0[D1s]:2.启动流程（GUI桌面加载部分）跟踪笔记

文章目录0. 控制台输出信息等级设置0.1 设置log level 4 无法正常启动1.宏观启动流程1.1 控制台入口函数finsh_thread_entry()执行《startup.sh》1.2 《startup.sh》启动桌面GUI模块1.2.1 《startup.sh》加载 desktop.mod1.2.2 desktop.mod加载 init.axf1.2.3 init.axf 介绍1.…
阅读更多...
C#与三菱PLC MC协议通信,Java与三菱PLC MC协议通信

C#与三菱PLC MC协议通信,Java与三菱PLC MC协议通信

三菱PLC的MC协议是一种常用的通信协议&#xff0c;用于实现三菱PLC与其他设备之间的通信。以下是一些关于MC协议的基本信息&#xff1a;协议格式MC协议的通信数据格式如下&#xff1a;数据头网络编号PC编号目标模块IO编号目标模块站号本机模块IO编号本机模块站号请求数据长度请…
阅读更多...
Linud SSH与SCP的配置

Linud SSH与SCP的配置

目录 配置SSH协议 配置服务器通过密钥进行认证 配置SCP完成文件传输 ssh协议讲解 SSH协议理论讲解_静下心来敲木鱼的博客-CSDN博客https://blog.csdn.net/m0_49864110/article/details/128500490?ops_request_misc%257B%2522request%255Fid%2522%253A%2522167704203816800…
阅读更多...
不加大资金投入，仅凭智能名片如何解决企业营销难题的？

不加大资金投入，仅凭智能名片如何解决企业营销难题的？

中国90%以上的中小企业想要竞争和发展&#xff0c;就必须推广自己的品牌&#xff0c;提高自己的知名度。在小程序之前&#xff0c;APP是主流&#xff0c;但大多数中小企业负担不起APP的开发和昂贵的营销成本。 进入微信互联网时代后&#xff0c;为了帮助企业以更低的成本获得…
阅读更多...
浙大MEM现场小组复试经验分享

浙大MEM现场小组复试经验分享

作为2019年上岸浙大MEM项目的学姐一枚&#xff0c;很高兴收到杭州达立易考教育老师的邀请&#xff0c;给大家分享下现场面试的经历。先来看下复试流程是怎么样的。1、体检所有考生须参加。体检需在复试前完成&#xff08;未体检考生不得参加复试&#xff09;。 2、资格审查&…
阅读更多...
历时半年！从外包到现在阿里网易25K，分享一下自己的涨薪经验

历时半年！从外包到现在阿里网易25K，分享一下自己的涨薪经验

前言 首先自我介绍一下&#xff0c;本人普通一本毕业&#xff0c;年初被老东家裁员干掉了&#xff0c;之后一直住在朋友那混吃等死&#xff0c;转折是今年年后&#xff0c;二月初的时候和大佬吃了个饭&#xff0c;觉得自己不能这样下去了&#xff0c;拿着某大佬给我的面试资料…
阅读更多...
你知道IT运维的本质是什么吗？

你知道IT运维的本质是什么吗？

大家好&#xff0c;我是技福的小咖老师。 之前看到个文章&#xff0c;说运维的本质是“可视化”&#xff0c;甚至还有人说是DevOps。不可否认&#xff0c;“可视化”是运维过程中非常重要的一个环节&#xff1b;DevOps则是开发运维一体化非常重要的工具。 究其根本&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023