redis本地安装和Redisson锁实现设计相关源码解析

已于 2022-03-02 17:39:36 修改
阅读量499 收藏 1
点赞数 1
分类专栏： redis 文章标签： redis java 数据库
于 2022-02-26 17:31:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38976745/article/details/123031505
版权

Redisson简介

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。

Redisson在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的一系列优势，在Java实用工具包中常用接口的基础上，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。
兼容 Redis 2.6+ and JDK 1.6+，使用Apache License 2.0授权协议，阅读 wiki 来获取更多使用信息
摘自：百度百科

windows上安装redis服务

下载地址：
https://github.com/MicrosoftArchive/redis/releases

Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择，这里我们下载 Redis-x64-xxx.zip压缩包到 E 盘文件夹下。

一、Redis临时服务
1.打开cmd，进入到刚才解压到的目录，启动临时服务命令：

redis-server.exe redis.windows.conf

备注：通过这个命令，会创建Redis临时服务，不会在window Service列表出现Redis服务名称和状态，此窗口关闭，服务会自动关闭。
在这里插入图片描述
二、打开另一个cmd窗口，客户端调用命令：

redis-cli.exe -h 127.0.0.1 -p 6379

在这里插入图片描述
尝试一下是否可以正常使用：
例如：

set myredis value
get myredis

在这里插入图片描述
设置和返回均正常，说明我们的redis已经本地正常启动以及可以使用了（本次仅仅使用单机模式进行说明）

三、设置密码
一般我们本地使用学习可以不进行密码设置，如果想更改设置可以按照如下操作：
打开redis安装目录：E:\Redis-x64-3.0.504-1
编辑：redis.windows-service.conf
在这里插入图片描述

把 #requirepass foobared 的#号去掉改为自己的密码即可

设置好保存后，若要使设置起作用，需要重启redis服务

端口号和ip同理
在这里插入图片描述
我们来操作一下更改密码
在这里插入图片描述
关闭redis服务，临时服务直接关闭cmd窗口即可，然后重新打开redis服务：进入指定安装目录，打开cmd窗口，执行命令：

redis-server.exe redis.windows.conf

在这里插入图片描述
服务已经启动成功了，打开另一个cmd窗口，客户端调用：redis-cli.exe -h 127.0.0.1 -p 6379 -a test
此时已经可以正常使用了。
在这里插入图片描述
好了，上面的操作基本就已经完成了redis本地服务的安装和启动，不过上述是开启的临时服务，如果不想出现关闭窗口会关闭服务，可以开启windows的redis服务，具体操作如下：
1.进入Redis安装包目录，安装服务：

redis-server.exe --service-install redis.windows.conf --service-name redisserver1 --loglevel verbose

win+r -> services.msc,可以看到服务安装成功
在这里插入图片描述

常用的几个命令：

安装服务：redis-server.exe --service-install redis.windows.conf --service-name redisserver1 --loglevel verbose
启动服务：redis-server.exe  --service-start --service-name redisserver1
停止服务：redis-server.exe  --service-stop --service-name redisserver1
卸载服务：redis-server.exe  --service-uninstall--service-name redisserver1

具体就不进行操作了，网上有很多教程，大家可以参考。

可视化工具-连接本地redis

具体可以使用参考：https://blog.csdn.net/u012723183/article/details/103409820
我直接使用RedisDesktopManager进行连接：
在这里插入图片描述
在这里插入图片描述

本地服务和可视化工具连接后，我们就可以进入今天的正题redisson了

redisson官网

https://redisson.org/

redisson GitHub地址

https://github.com/redisson/redisson/releases

回顾常见锁

锁的基本概念回顾
JUC 锁
悲观锁：没有获取到锁的线程会直接阻塞等待。
将一个线程从用户态切换到内核态；
后期唤醒线程成本是非常高，内核态切换到用户态；
乐观锁：
乐观：没有获取到锁的线程不会一直阻塞等待，而是通过
自旋的形式。比如CAS 缺点：比较消耗cpu的资源。

阻塞式与阻塞赛式：
阻塞式锁：没有获取到锁的线程就一直阻塞；
非阻塞式 ：没有获取到锁的线程就不会阻塞；

锁重入性：当前线程获取到锁之后，不断的实现复用。

公平性与非公平锁：
默认的使用synchronized 非公平锁，靠cpu争抢获取
锁。
公平锁：根据获取锁的时间排列，依赖于链表结构。

重量级锁：实际上就是悲观锁，没有获取到锁的线程
直接变为阻塞状态。
悲观锁：当没有获取锁的线程，会阻塞。
乐观锁： 通过cas自旋，一直不断死循环重试获取锁 缺点消耗cpu资源。
阻塞与非阻塞锁： 阻塞：没有获取到锁就阻塞，非阻塞锁： 没有获取到锁的
线程不会阻塞。
重量级锁： 没有获取到锁直接阻塞，没有自旋。
公平锁与非公平锁： synchronized 默认的情况下属于非公平锁，根据争抢的形式获取锁
公平锁，根据获取的锁时间排列获取锁。

Synchronized锁与分布式锁区别

Synchronized锁适合于单个jvm中保证线程安全问题
分布式锁适合于多个jvm之间跨网络通讯方式实现分布式锁

常用的实现分布式锁方式

1.基于数据库实现—淘汰
2.基于Zookeeper
3.基于Redis setnx实现
4.Redis框架 Redisson、RedisLock

Redisson环境搭建

Maven依赖

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

为什么使用redisson实现锁

1、redis实现分布式锁的简单思路
redis分布式锁的实现思路可以概括为：在redis中设置一个值表示加了锁，然后获取到该锁后即可进行一系列业务逻辑操作，最后删除这个key(或设置过期时间)即表示释放了该锁。
2、redisson作为一款优秀的企业级开源redis client，也提供了分布式锁的实现，并且屏蔽了很多细节的处理，减少了一般公司程序员的工作，提供了较稳定的技术方案。
2.1、redisson所有指令都通过lua脚本执行，保证了操作的原子性
2.2、redisson设置了watchdog看门狗，“看门狗”的逻辑保证了没有死锁发生

redisson实现分布式锁的原理

在这里插入图片描述

redisson分布式锁实现源码

使用lua脚本在redis上创建hash key；
创建成功，则开启一个看门狗续命线程一直不断续命；
该key默认是在30s 有效期，续命是每隔10s续命一次。

Key:自定义key名称 value key=uuid+线程id value：重入次数

//leaseTime默认为-1
public void lock(long leaseTime, TimeUnit unit) throws InterruptedException {
    long threadId = Thread.currentThread().getId();//获取当前线程ID
    Long ttl = tryAcquire(leaseTime, unit, threadId);//尝试加锁
    // 如果为空，当前线程获取锁成功，否则已经被其他客户端加锁
    if (ttl == null) {
        return;
    }
    //等待释放，并订阅锁
    RFuture<RedissonLockEntry> future = subscribe(threadId);
    commandExecutor.syncSubscription(future);
    try {
        while (true) {
            // 重新尝试获取锁
            ttl = tryAcquire(leaseTime, unit, threadId);
            // 成功获取锁
            if (ttl == null) {
                break;
            }
            // 等待锁释放
            if (ttl >= 0) {
                getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {
                getEntry(threadId).getLatch().acquire();
            }
        }
    } finally {
        // 取消订阅
        unsubscribe(future, threadId);
    }
}

获取锁

private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
    if (leaseTime != -1) {   //在lock.lock()的时候，已经声明了leaseTime为-1，尝试加锁
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    //监听事件，订阅消息
    ttlRemainingFuture.addListener(new FutureListener<Long>() {
        @Override
        public void operationComplete(Future<Long> future) throws Exception {
            if (!future.isSuccess()) {
                return;
            }
            Long ttlRemaining = future.getNow();
            // lock acquired
            if (ttlRemaining == null) {
                //获取新的超时时间
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;  //返回ttl时间
}

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);

    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
              "if (redis.call('exists', KEYS[1]) == 0) then " +
                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                  "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "return redis.call('pttl', KEYS[1]);",
                Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}

redisson加锁lua脚本

KEYS1 ：需要加锁的key，这里需要是字符串类型。
ARGV1 ：锁的超时时间，防止死锁
ARGV2 ：锁的唯一标识，也就是刚才介绍的 id（UUID.randomUUID()） + “:” + threadId

--检查key是否被占用了，如果没有则设置超时时间和唯一标识，初始化value=1
if (redis.call('exists', KEYS[1]) == 0) then
  redis.call('hset', KEYS[1], ARGV[2], 1);
  redis.call('pexpire', KEYS[1], ARGV[1]);
  return nil; 
end; 
--如果锁重入,需要判断锁的key field 都一致情况下 value 加一 
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then 
  redis.call('hincrby', KEYS[1], ARGV[2], 1);
  --锁重入重新设置超时时间  
  redis.call('pexpire', KEYS[1], ARGV[1]); 
  return nil; 
end;
--返回剩余的过期时间
return redis.call('pttl', KEYS[1]);

Lua脚本Redis

Redis在2.6推出了脚本功能，允许开发者使用Lua语言编写脚本传到Redis中执行。使用脚本的好处如下:
减少网络开销：本来5次网络请求的操作，可以用一个请求完成，原先5次请求的逻辑放在redis服务器上完成。使用脚本，减少了网络往返时延。这点跟管道类似。
原子操作：Redis会将整个脚本作为一个整体执行，中间不会被其他命令插入。管道不是原子的。
替代redis的事务功能：redis自带的事务功能很鸡肋，报错不支持回滚，而redis的lua脚本几乎实现了 常规的事务功能，支持报错回滚操作，官方推荐如果要使用redis的事务功能可以用redis lua替代。

redisson释放锁lua脚本

调用lua脚本，修改重入的次数，如果重入次数小于0的情况下，直接将该key删除。

--如果keys[1]不存在，则发布消息，说明已经被解锁了
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('publish', KEYS[2], ARGV[1]);
    return 1;
end;
--key和field不匹配，说明当前客户端线程没有持有锁，不能主动解锁。
if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then
    return nil;
end;
--将value减1，这里主要用在重入锁
local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); 
if (counter > 0) then 
    redis.call('pexpire', KEYS[1], ARGV[2]); 
    return 0; 
else 
--删除key并消息
    redis.call('del', KEYS[1]); 
    redis.call('publish', KEYS[2], ARGV[1]); 
    return 1;
end; 
return nil;

续命设计-看门狗

当获取锁的jvm业务超时了，一直没有释放锁 默认Redis key是30s
过期，为了避免key过期了，业务超时的问题。
默认的情况下Redisson采用每隔10s续命延迟过期的key的时间。

获取锁成功之后，创建一个定时任务。

ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    if (ee == null) {
        return;
    }
    
    Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
            ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
            if (ent == null) {
                return;
            }
            Long threadId = ent.getFirstThreadId();
            if (threadId == null) {
                return;
            }
            
            RFuture<Boolean> future = renewExpirationAsync(threadId);
            future.onComplete((res, e) -> {
                if (e != null) {
                    log.error("Can't update lock " + getName() + " expiration", e);
                    return;
                }
                
                if (res) {
                    // reschedule itself
                    renewExpiration();
                }
            });
        }
    }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
    
    ee.setTimeout(task);
}

protected RFuture<Boolean> renewExpirationAsync(long threadId) {
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                "return 1; " +
            "end; " +
            "return 0;",
        Collections.<Object>singletonList(getName()), 
        internalLockLeaseTime, getLockName(threadId));
}

其实redisson还有很多很多功能和优秀的设计，本文只是简单讲述其中一小部分。
下次见！

Little、小蜗
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
记录redisson实现redis分布式事务锁
04-24
自己封装redisson方法，同时通过注解的方式加入redis分布式事务锁，可靠。
redis 分布式锁实现案例和源码解析备注
最新发布
04-21
redis 分布式锁实现案例和源码解析备注 * 多线程 * 使用redis事务的方法 * 加事务 乐观锁 * watch命令监控key有没有更改 * multi命令开启事务
Redis本地安装（基础篇）
maomao的博客
07-12 6730
Redis学习用本地安装
基于Springboot的Redission 分布式锁配置及使用（单机、集群、哨兵、主从）
qq_39091806的博客
09-29 3695
【代码】基于Springboot的Redission 分布式锁配置及使用（单机、集群、哨兵、主从）
redission集群搭建
myBackAtOne的博客
06-23 3079
1：redission 集群 yml 配置文件进行配置
Redisson连接Redis单机&集群&哨兵配置示例
idto315的博客
09-21 4077
基于spring-boot-starter-data-redis原生配置集成Redission，连接不同模式（单机/主从/哨兵/集群）的Redis服务
搭建redis
beyourself
05-09 215
介绍：Redis的一些优点。 借鉴百度百科 介绍：异常快- Redis非常快，每秒可执行大约110000次的设置(SET)操作，每秒大约可执行81000次的读取/获取(GET)操作。 支持丰富的数据类型- Redis支持开发人员常用的大多数数据类型，例如列表，集合，排序集和散列等等。这使得Redis很容易被用来解决各种问题，因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。 操...
Redisson教程
weixin_30325071的博客
04-24 3067
Redisson入门 　　　　Author:Ricky Date:2017-04-24 Redisson概述 Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特...
Redis 安装、配置及其简单操作
Gettler的博客
05-27 191
Redisson是一个基于Redis实现的分布式、可伸缩的Java数据结构集合。包含了诸如Map、Queue.Lock、semaphore、AtomicLong等强大功能。Lettuce是基于Netty实现的，支持同步、异步和响应式编程方式，并且是线程安全的。支持Redis的哨兵模式、集群模式和管道模式。但是Jedis实例是线程不安全的，多线程环境下需要基于连接池来使用。以Redis命令作为方法名称，学习成本低，简单实用。将路径添加至环境变量。
redis客户端redisson实战
热门推荐
猿类崛起
10-16 20万+
  redis 学习问题总结 http://aperise.iteye.com/blog/2310639 ehcache memcached redis 缓存技术总结 http://aperise.iteye.com/blog/2296219 redis-stat 离线安装 http://aperise.iteye.com/blo...
Redis系列：安装和基础知识（一）
小唐的博客
11-21 192
在Linux中使用docker安装 1. docker pull redis:latest //下载redis 2. docker images //查看 3. docker run -itd --name redis-twy -p 6379:6379 redis //运行redis容器 4. docker ps //查看是否运行 5. docker exec -it redis-twy /bin/bash //使用 docker exec -it redis /bin/bash进入redis
Redis安装以及使用
qq_41114884的博客
03-22 582
Redis是一个高性能的内存键值存储数据库，它支持多种数据结构，如字符串、哈希、列表、集合和有序集合等。Redis的出色性能归功于其使用内存作为主要存储介质，以及使用单线程模型避免了锁的开销。此外，Redis还支持数据持久化和复制，使其更具可靠性和可扩展性。Redis常用于缓存、会话管理和消息队列等场景，成为现代互联网应用开发中不可或缺的技术。接下来我们学习一下安装和环境搭建以及简单使用
Redis分布式锁实现Redisson 15问.doc
07-09
Redis分布式锁实现Redisson 15问.doc
redis和redisson实现分布式锁
05-26
redis分布式锁demo。包括守护线程的锁延迟过期时间，锁竞争时的循环重试
Redis框架Jedis及Redisson对比解析
08-18
主要介绍了Redis框架Jedis及Redisson对比解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【redis】windows下Redis的下载、安装、配置、单元测试、redis免费可视化工具Another Redis Desktop Manager
MS_SONG的博客
11-23 772
windows下Redis的下载、安装、配置、单元测试
Redisson启动及服务、命令模式分析
weixin_40455124的博客
07-07 987
以AtomicDoubleExamples为入口，初步分析redisson启动及命令、服务 Redisson 启动的主类为org.redisson.Redisson, 启动主要是初始化connection pool，还有两个比较少用的evictionScheduler（local cache housekeeping？）及local cache用的WriteBehindService ？ Red...
搭建Redis 和 Redisson 项目通用组件
huangchong0107的博客
01-11 548
redis 和redis作为通用组件 提供缓存工具类 和 分布式锁工具类
redis sentinel锁和 redisson分布式锁有什么区别
05-20
Redis Sentinel 锁是一种基于 Redis Sentinel 的锁实现，它通过 Redis Sentinel 提供的高可用性机制，确保了锁的可用性和可靠性，能够保证在 Redis 主节点失败时，自动切换到 Redis 从节点，从而实现高可用性。 Redisson 分布式锁是一种基于 Redisson 的锁实现，它通过 Redis 的分布式机制，将锁分布在多个 Redis 节点上，从而实现分布式锁的功能。Redisson 还提供了诸如可重入锁、公平锁、读写锁等高级锁功能，以及异步执行、过期时间等特性。 总的来说，Redis Sentinel 锁适用于单节点 Redis 环境下的锁操作，具有高可用性和可靠性；而 Redisson 分布式锁适用于分布式 Redis 环境下的锁操作，具有更多的高级锁功能和特性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值