Redis介绍

参考地址:https://blog.csdn.net/turbo_zone/article/details/83422215

redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。在此基础上,redis支持各种不同方式的排序。与memcached一样,为了保证效率,数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了master-slave(主从)同步。

Redis的优缺点

优点

  1. 速度快,因为数据存在内存中,类似于HashMap,HashMap的优势就是查找和操作的时间复杂度都是O(1)
  2. 支持丰富数据类型,支持string,list,set,sorted set,hash
  3. 支持事务,操作都是原子性,所谓的原子性就是对数据的更改要么全部执行,要么全部不执行
  4. 丰富的特性:可用于缓存,消息,按key设置过期时间,过期后将会自动删除

缺点

在不使用框架的情况下使用起来较为麻烦

分布式Redis的搭建

搭建集群的第一件事情我们需要一些运行在集群模式的Redis实例. 这意味这集群并不是由一些普通的Redis实例组成的,集群模式需要通过配置启用,开启集群模式后的Redis实例便可以使用集群特有的命令和特性了.
下面是一个最少选项的集群的配置文件:

port 7000

cluster-enabled yes

cluster-config-file nodes.conf

cluster-node-timeout 5000

appendonly yes

文件中的 cluster-enabled 选项用于开实例的集群模式, 而 cluster-conf-file 选项则设定了保存节点配置文件的路径, 默认值为 nodes.conf.节点配置文件无须人为修改, 它由 Redis 集群在启动时创建, 并在有需要时自动进行更新。

要让集群正常运作至少需要三个主节点,不过在刚开始试用集群功能时, 强烈建议使用六个节点: 其中三个为主节点, 而其余三个则是各个主节点的从节点。

为了方便测试,直接在同一台计算机内建立六个文件夹7000到7005,分别表示六个Redis实例,在文件夹 7000 至 7005 中, 各创建一个 redis.conf 文件, 文件的内容使用上面的示例配置文件, 但记得将配置中的端口号从 7000 改为与文件夹名字相同的号码。

从 Redis Github 页面 的 unstable 分支中取出最新的 Redis 源码, 编译出可执行文件 redis-server , 并将文件复制到 cluster-test 文件夹, 然后使用类似以下命令, 在每个标签页中打开一个实例:

/redis-server ./redis.conf

现在我们已经有了六个正在运行中的 Redis 实例, 接下来我们需要使用这些实例来创建集群, 并为每个节点编写配置文件。

通过使用 Redis 集群命令行工具 redis-trib , 编写节点配置文件的工作可以非常容易地完成: redis-trib 位于 Redis 源码的 src 文件夹中, 它是一个 Ruby 程序, 这个程序通过向实例发送特殊命令来完成创建新集群, 检查集群, 或者对集群进行重新分片(reshared)等工作。

./redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 
127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005

这个命令在这里用于创建一个新的集群, 选项–replicas 1 表示我们希望为集群中的每个主节点创建一个从节点。

之后跟着的其他参数则是这个集群实例的地址列表,3个master3个slave redis-trib 会打印出一份预想中的配置给你看, 如果你觉得没问题的话, 就可以输入 yes , redis-trib 就会将这份配置应用到集群当中,让各个节点开始互相通讯,最后可以得到如下信息:

[OK] All 16384 slots covered

这表示集群中的 16384 个槽都有至少一个主节点在处理, 集群运作正常。

分布式Redis的原理

由上文可知,Redis是以哈希槽的形式对集群进行划分的,整个集群的哈希槽一共有16384个,在有3个Redis实例的情况下,节点A包含从0到5500的哈希槽,节点B包含从5501到11000 的哈希槽,节点C包含从11001到16384的哈希槽。当有新的节点添加进来的时候,会从当前的各个节点中选取一定的槽分配给新添加的节点,当有节点从集群中被删除时,则会将当前节点的槽分配给集群中其他正在运行的节点。每当有新的key添加到Redis中时,会根据算法算出相应的哈希槽来找到对应的集群节点。

Redisson介绍

什么是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的关注分离(Separation of Concern),从而让使用者能够将精力更集中地放在处理业务逻辑上。

Redisson的使用

Redisson配置(以spring XML为例)

Maven配置

  1. <dependency>
  2. <groupId>org.redisson</groupId>
  3. <artifactId>redisson</artifactId>
  4. <version>2.2.12</version>
  5. </dependency>
  6. <dependency>
  7. <groupId>com.fasterxml.jackson.core</groupId>
  8. <artifactId>jackson-annotations</artifactId>
  9. <version>2.6.0</version>
  10. </dependency>

Spring XML配置

  1. <redisson:client
  2. id="redisson"
  3. name="redisson1,redisson2"
  4. threads="0"
  5. netty-threads="0"
  6. codec-ref="myCodec"
  7. transport-mode="NIO"
  8. redisson-reference-enabled="true"
  9. codec-provider-ref="myCodecProvider"
  10. resolver-provider-ref="myResolverProvider"
  11. executor-ref="myExecutor"
  12. event-loop-group-ref="myEventLoopGroup"
  13. >
  14. <!--
  15. 这里的name属性和qualifier子元素不能同时使用。
  16.  
  17. id和name的属性都可以被用来作为qualifier的备选值。
  18. -->
  19. <!--<qualifier value="redisson3"/>-->
  20. <redisson:cluster-servers
  21. idle-connection-timeout="10000"
  22. ping-timeout="1000"
  23. connect-timeout="10000"
  24. timeout="3000"
  25. retry-attempts="3"
  26. retry-interval="1500"
  27. reconnection-timeout="3000"
  28. failed-attempts="3"
  29. password="do_not_use_if_it_is_not_set"
  30. subscriptions-per-connection="5"
  31. client-name="none"
  32. load-balancer-ref="myLoadBalancer"
  33. subscription-connection-minimum-idle-size="1"
  34. subscription-connection-pool-size="50"
  35. slave-connection-minimum-idle-size="10"
  36. slave-connection-pool-size="64"
  37. master-connection-minimum-idle-size="10"
  38. master-connection-pool-size="64"
  39. read-mode="SLAVE"
  40. subscription-mode="SLAVE"
  41. scan-interval="1000"
  42. >
  43. <redisson:node-address value="redis://127.0.0.1:6379" />
  44. <redisson:node-address value="redis://127.0.0.1:6380" />
  45. <redisson:node-address value="redis://127.0.0.1:6381" />
  46. </redisson:cluster-servers>
  47. </redisson:client>
  1. <!-- 最基本配置 -->
  2. <redisson:client>
  3. <redisson:cluster-servers>
  4. <redisson:node-address value="redis://127.0.0.1:6379" />
  5. <redisson:node-address value="redis://127.0.0.1:6380" />
  6. <redisson:node-address value="redis://127.0.0.1:6381" />
  7. ...
  8. </redisson:cluster-servers>
  9. </redisson:client>

更多配置方法

Redisson实现分布式锁

锁的种类

可重入锁

  1. RLock lock = redisson.getLock("anyLock");
  2. // 最常见的使用方法
  3. lock.lock();
  4. ...
  5. lock.unlock()
  1. // 加锁以后10秒钟自动解锁
  2. // 无需调用unlock方法手动解锁
  3. lock.lock(10, TimeUnit.SECONDS);
  4.  
  5. // 尝试加锁,最多等待100秒,上锁以后10秒自动解锁
  6. boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
  7. ...
  8. lock.unlock();

公平锁

  1. RLock fairLock = redisson.getFairLock("anyLock");
  2. // 最常见的使用方法
  3. fairLock.lock();
  1. // 10秒钟以后自动解锁
  2. // 无需调用unlock方法手动解锁
  3. fairLock.lock(10, TimeUnit.SECONDS);
  4.  
  5. // 尝试加锁,最多等待100秒,上锁以后10秒自动解锁
  6. boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
  7. ...
  8. fairLock.unlock();
  1.  

Redisson同时还为分布式可重入公平锁提供了异步执行的相关方法:

  1. RLock fairLock = redisson.getFairLock("anyLock");
  2. fairLock.lockAsync();
  3. fairLock.lockAsync(10, TimeUnit.SECONDS);
  4. Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);

联锁

基于Redis的Redisson分布式联锁RedissonMultiLock对象可以将多个RLock对象关联为一个联锁,每个RLock对象实例可以来自于不同的Redisson实例。

  1. RLock lock1 = redissonInstance1.getLock("lock1");
  2. RLock lock2 = redissonInstance2.getLock("lock2");
  3. RLock lock3 = redissonInstance3.getLock("lock3");
  4.  
  5. RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
  6. // 同时加锁:lock1 lock2 lock3
  7. // 所有的锁都上锁成功才算成功。
  8. lock.lock();
  9. ...
  10. lock.unlock();

红锁

基于Redis的Redisson红锁RedissonRedLock对象实现了Redlock介绍的加锁算法。该对象也可以用来将多个RLock对象关联为一个红锁,每个RLock对象实例可以来自于不同的Redisson实例。

  1. RLock lock1 = redissonInstance1.getLock("lock1");
  2. RLock lock2 = redissonInstance2.getLock("lock2");
  3. RLock lock3 = redissonInstance3.getLock("lock3");
  4.  
  5. RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
  6. // 同时加锁:lock1 lock2 lock3
  7. // 红锁在大部分节点上加锁成功就算成功。
  8. lock.lock();
  9. ...
  10. lock.unlock();

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

  1. RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
  2. // 给lock1,lock2,lock3加锁,如果没有手动解开的话,10秒钟后将会自动解开
  3. lock.lock(10, TimeUnit.SECONDS);
  4.  
  5. // 为加锁等待100秒时间,并在加锁成功10秒钟后自动解开
  6. boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
  7. ...
  8. lock.unlock();

读写锁

  1. RReadWriteLock rwlock = redisson.getLock("anyRWLock");
  2. // 最常见的使用方法
  3. rwlock.readLock().lock();
  4. // 或
  5. rwlock.writeLock().lock();

信号量

  1. RSemaphore semaphore = redisson.getSemaphore("semaphore");
  2. semaphore.acquire();
  3. //或
  4. semaphore.acquireAsync();
  5. semaphore.acquire(23);
  6. semaphore.tryAcquire();
  7. //或
  8. semaphore.tryAcquireAsync();
  9. semaphore.tryAcquire(23, TimeUnit.SECONDS);
  10. //或
  11. semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
  12. semaphore.release(10);
  13. semaphore.release();
  14. //或
  15. semaphore.releaseAsync();

可过期性信号量

基于Redis的Redisson可过期性信号量(PermitExpirableSemaphore)是在RSemaphore对象的基础上,为每个信号增加了一个过期时间。每个信号可以通过独立的ID来辨识,释放时只能通过提交这个ID才能释放。

  1. RPermitExpirableSemaphore semaphore = redisson.getPermitExpirableSemaphore("mySemaphore");
  2. String permitId = semaphore.acquire();
  3. // 获取一个信号,有效期只有2秒钟。
  4. String permitId = semaphore.acquire(2, TimeUnit.SECONDS);
  5. // ...
  6. semaphore.release(permitId);

闭锁

  1. RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
  2. latch.trySetCount(1);
  3. latch.await();
  4.  
  5. // 在其他线程或其他JVM里
  6. RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
  7. latch.countDown();

锁的原理

在Redisson中,使用key来作为是否上锁的标志,当通过getLock(String key)方法获得相应的锁之后,这个key即作为一个锁存储到Redis集群中,在接下来如果有其他的线程尝试获取名为key的锁时,便会向集群中进行查询,如果能够查到这个锁并发现相应的value的值不为0,则表示已经有其他线程申请了这个锁同时还没有释放,则当前线程进入阻塞,否则由当前线程获取这个锁并将value值加一,如果是可重入锁的话,则当前线程每获得一个自身线程的锁,就将value的值加一,而每释放一个锁则将value值减一,直到减至0,完全释放这个锁。因为底层是基于分布式的Redis集群,所以Redisson实现了分布式的锁机制。

加锁

在Redisson中,加锁需要以下三个参数:

KEYS[1] :需要加锁的key,这里需要是字符串类型。

ARGV[1] :锁的超时时间,防止死锁

ARGV[2] :锁的唯一标识,id(UUID.randomUUID()) + “:” + threadId

  1. Future tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId) {
  2. internalLockLeaseTime = unit.toMillis(leaseTime);
  3. return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_LONG,
  4. // 检查是否key已经被占用,如果没有则设置超时时间和唯一标识,初始化value=1
  5. "if (redis.call('exists', KEYS[1]) == 0) then " +
  6.         // 使用hasn数据结构,创建名为key的hash表,并添加field=ARGV[2],value=1
  7. "redis.call('hset', KEYS[1], ARGV[2], 1); " +
  8. // 为hash表设置过期时间
  9. "redis.call('pexpire', KEYS[1], ARGV[1]); " +
  10. "return nil; " +
  11. "end; " +
  12. // 如果锁重入,需要判断锁的key+ field 是否一致
  13. "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
  14. // 两者都一致的情况下, value 加一
  15. "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
  16. //锁重入重新设置超时时间
  17. "redis.call('pexpire', KEYS[1], ARGV[1]); " +
  18. "return nil; " +
  19. "end; " +
  20. // 返回剩余的过期时间
  21. "return redis.call('pttl', KEYS[1]);",
  22. Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
  23. }

解锁

在Redisson中解锁需要以下五个参数:

KEYS[1] :需要加锁的key,这里需要是字符串类型。

KEYS[2] :redis消息的ChannelName,一个分布式锁对应唯一的一个channelName:“redisson_lock__channel__{” + getName() + “}”

ARGV[1] :reids消息体,这里只需要一个字节的标记就可以,主要标记redis的key已经解锁,再结合redis的Subscribe,能唤醒其他订阅解锁消息的客户端线程申请锁。

ARGV[2] :锁的超时时间,防止死锁

ARGV[3] :锁的唯一标识,也就是刚才介绍的 id(UUID.randomUUID()) + “:” + threadId

  1. public void unlock() {
  2. Boolean opStatus = commandExecutor.evalWrite(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
  3. // 如果key已经不存在,说明已经被解锁,直接发布(publihs)redis消息
  4. "if (redis.call('exists', KEYS[1]) == 0) then " +
  5. "redis.call('publish', KEYS[2], ARGV[1]); " +
  6. "return 1; " +
  7. "end;" +
  8. // key和field不匹配,说明当前客户端线程没有持有锁,不能主动解锁。
  9. "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
  10. "return nil;" +
  11. "end; " +
  12. "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
  13. // 如果counter>0说明锁在重入,不能删除key
  14. "if (counter > 0) then " +
  15. "redis.call('pexpire', KEYS[1], ARGV[2]); " +
  16. "return 0; " +
  17. "else " +
  18. // 删除key并且publish 解锁消息
  19. "redis.call('del', KEYS[1]); " +
  20. "redis.call('publish', KEYS[2], ARGV[1]); " +
  21. "return 1; "+
  22. "end; " +
  23. "return nil;",
  24. Arrays.asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(Thread.currentThread().getId()));
  25. if (opStatus == null) {
  26. throw new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
  27. + id + " thread-id: " + Thread.currentThread().getId());
  28. }
  29. // 解锁成功之后取消更新锁expire的时间任务
  30. if (opStatus) {
  31. cancelExpirationRenewal();
  32. }
  33. }

注意点

Redisson 默认的 CommandExecutor 实现是通过 eval 命令来执行 Lua 脚本,所以要求 Redis 的版本必须为 2.6 或以上,否则可能要自己来实现

  1.  
  1.  
  1.  
  1.  
  1.  

利用Redisson实现分布式锁及其底层原理解析的更多相关文章

  1. Redisson实现Redis分布式锁的底层原理

    一.写在前面 现在面试,一般都会聊聊分布式系统这块的东西.通常面试官都会从服务框架(Spring Cloud.Dubbo)聊起,一路聊到分布式事务.分布式锁.ZooKeeper等知识.所以咱们这篇文章 ...

  2. Redisson实现分布式锁(3)—项目落地实现

    Redisson实现分布式锁(3)-项目落地实现 有关Redisson实现分布式锁前面写了两篇博客作为该项目落地的铺垫. 1.Redisson实现分布式锁(1)---原理 2.Redisson实现分布 ...

  3. Redisson 实现分布式锁的原理分析

    写在前面 在了解分布式锁具体实现方案之前,我们应该先思考一下使用分布式锁必须要考虑的一些问题.​ 互斥性:在任意时刻,只能有一个进程持有锁. 防死锁:即使有一个进程在持有锁的期间崩溃而未能主动释放锁, ...

  4. Redisson 实现分布式锁原理分析

    Redisson 实现分布式锁原理分析   写在前面 在了解分布式锁具体实现方案之前,我们应该先思考一下使用分布式锁必须要考虑的一些问题.​ 互斥性:在任意时刻,只能有一个进程持有锁. 防死锁:即使有 ...

  5. Redisson实现分布式锁(1)---原理

    Redisson实现分布式锁(1)---原理 有关Redisson作为实现分布式锁,总的分3大模块来讲. 1.Redisson实现分布式锁原理 2.Redisson实现分布式锁的源码解析 3.Redi ...

  6. 冷饭新炒:理解Redisson中分布式锁的实现

    前提 在很早很早之前,写过一篇文章介绍过Redis中的red lock的实现,但是在生产环境中,笔者所负责的项目使用的分布式锁组件一直是Redisson.Redisson是具备多种内存数据网格特性的基 ...

  7. redisson之分布式锁实现原理(三)

    官网:https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95 一.什么是分布式锁 1.1.什么是分布式锁 分布式锁,即分布式系统中的锁 ...

  8. 从源码层面深度剖析Redisson实现分布式锁的原理(全程干货,注意收藏)

    Redis实现分布式锁的原理 前面讲了Redis在实际业务场景中的应用,那么下面再来了解一下Redisson功能性场景的应用,也就是大家经常使用的分布式锁的实现场景. 引入redisson依赖 < ...

  9. Redisson实现分布式锁

    转: Redisson实现分布式锁 Redisson文档参考:https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95 redis是实现 ...

随机推荐

  1. JS让函数只调用一次

    1 .  在第一次调用函数时,就将该函数内容腾空,以到达函数仅调用一次 ———————————————————————————————— 2 . 设置布尔值来控制后面的函数调用 window.onlo ...

  2. java.sql.SQLException: Unknown system variable 'query_cache_size'

    改为 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java< ...

  3. Django【第8篇】:Django之查询知识点总结

    关于查询知识点总结 models.Book.objects.filter(**kwargs): querySet [obj1,obj2]models.Book.objects.filter(**kwa ...

  4. 细数不懂Spring底层原理带来的伤与痛

    原文链接:https://www.jianshu.com/p/c9de414221ac?utm_campaign=haruki&utm_content=note&utm_medium= ...

  5. lamba

    >>> from random import randint>>> allNums = []>>> for eachNum in range(10 ...

  6. v-if 和 v-show

    关于条件渲染 所谓条件渲染,就是根据不同的条件,使用不同的模板来生成 html. 在 Vue.js 中,使用 v-if 和 v-show 指令来控制条件渲染. 区别 v-show 会在app初始化的时 ...

  7. SpringBoot路径映射

    当然这个功能并非是springboot特有的,只是springboot提供了更简便的方法以供使用.     传统情况下我们跳转一个动态页面且并没有数据,也需要在controller中写一个跳转的con ...

  8. mysql WHERE语句 语法

    mysql WHERE语句 语法 作用:如需有条件地从表中选取数据,可将 WHERE 子句添加到 SELECT 语句.珠海大理石平尺 语法:SELECT 列名称 FROM 表名称 WHERE 列 运算 ...

  9. 软件工程 in MSRA 黄金点游戏-第一次结对编程

    简单介绍 第一次结对编程,邹欣老师选择了一个博弈游戏作为题目.博弈论是一门非常有趣的学科.之前竞赛时接触的博弈论大部分都是存在均衡点/必胜策略的.像这次这种多人参与,没有完美策略,你方唱罢我登台的游戏 ...

  10. IO重定向与管道

    一.三种IO设备 程序:数据+指令 或 数据结构+算法 程序必须能够读入输入然后经过加工来产生结果,其接受的输入可以是变量.数组.列表.文件等等,生产出来的结果可以使变量.数组.列表.文件等等.即: ...