Redisson分布式锁详细介绍

一、概述

官方网站 & 高性能版

官方描述：Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。

它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。
Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。
Redisson底层采用的是Netty 框架。支持Redis 2.8以上版本，支持Java1.6+以上版本。

二、配置

Redisson程序化的配置方法是通过构建Config对象实例来实现的，具体配置可参加API。下列基础的连接配置：

• 单机模式

// 默认连接地址 11:6379 无密码
RedissonClient redisson = Redisson.create();
// 指定
Config config = new Config();
config.useSingleServer().setAddress("redis://localhost:6379");
RedissonClient redisson = Redisson.create(config);

• 集群模拟

Config config = new Config();
config.useClusterServers()
    .setScanInterval(2000) // 集群状态扫描间隔时间，单位是毫秒
    //可以用"rediss://"来启用SSL连接
    .addNodeAddress("redis://11:7000", "redis://11:7001")
    .addNodeAddress("redis://11:7002");
RedissonClient redisson = Redisson.create(config);

• 哨兵模式

Config config = new Config();
config.useSentinelServers()
    .setMasterName("mymaster")
    //可以用"rediss://"来启用SSL连接
    .addSentinelAddress("11:26389", "11:26379")
    .addSentinelAddress("11:26319");
RedissonClient redisson = Redisson.create(config);

• 主从模式

Config config = new Config();
config.useMasterSlaveServers()
    //可以用"rediss://"来启用SSL连接
    .setMasterAddress("redis://11:6379")
    .addSlaveAddress("redis://11:6389", "redis://11:6332", "redis://11:6419")
    .addSlaveAddress("redis://11:6399");
RedissonClient redisson = Redisson.create(config);

三、分布式对象

• 特殊数据结构：BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque

//BigeSet示例
RBitSet set = redisson.getBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");

• 特殊组件：Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter

// 步隆过滤器示例
RBloomFilter<SomeObject> bloomFilter = redisson.getBloomFilter("sample");
// 初始化布隆过滤器，预计统计元素数量为55000000，期望误差率为03
bloomFilter.tryInit(55000000L, 03);
bloomFilter.add(new SomeObject("field1Value", "field2Value"));
bloomFilter.add(new SomeObject("field5Value", "field8Value"));
bloomFilter.contains(new SomeObject("field1Value", "field8Value"));

• 其他：Remote service, Spring cache, Executor service, Live Object service, Scheduler service

三、分布式锁

1、锁的类别

• 可重入锁（Reentrant Lock）

基于Redis的Redisson分布式可重入锁RLock，实现了

java.util.concurrent.locks.Lock

接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
RLock对象完全符合Java的Lock规范。也就是说只有拥有锁的进程才能解锁，其他进程解锁则会抛出

IllegalMonitorStateException

错误。

// 防止IllegalMonitorStateException异常
if (lock.isLocked() && lock.isHeldByCurrentThread()) {
    lock.unlock();
}

• 联锁（MultiLock）

基于Redis的Redisson分布式联锁RedissonMultiLock对象可以将多个RLock对象关联为一个联锁，每个RLock对象实例可以来自于不同的Redisson实例。
用于加锁不同ID集合时，只要执行集合与当前加锁集合有交集，就会阻塞等待。

RLock lock1 = redissonInstancegetLock("lock1");
RLock lock2 = redissonInstancegetLock("lock2");
RLock lock3 = redissonInstancegetLock("lock3");

RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
// 同时加锁：lock1 lock2 lock3
// 所有的锁都上锁成功才算成功。
lock.lock();
...
lock.unlock();

• 红锁（RedLock）

• 读写锁（ReadWriteLock）

写锁是一个排他锁(互斥锁，独享锁)；读锁是 一个共享锁。

• 信号量（Semaphore）

• 闭锁（CountDownLatch）

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与

java.util.concurrent.CountDownLatch

相似的接口和用法。

2、分布式锁Java应用示例

• 1)、引用maven依赖

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

• 2)、配置RedissonClient

MyRedissonConfig给容器配置一个RedissonClient实例即可，所有对redisson的使用都是通过RedissonClient对象。

@Configuration
public class MyRedissonConfig {
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        //1、创建配置
        Config config = new Config();
        //Redis url should start with redis:// or rediss:// (for SSL connection)
        //可以用"rediss://"来启用SSL连接
        config.useSingleServer()
                .setAddress("redis://localhost:6379")
                .setPassword("123456")
                .setDatabase(0);

        //2、根据Config创建出RedissonClient实例
        return Redisson.create(config);
    }
}

• 3):基础示例

@ResponseBody
@GetMapping("/hello")
public String hello() {
    //1、获取一把锁，只要锁的名字一样，就是同一把锁
    RLock lock = redisson.getLock("redisson:my‐lock");
    //2、加锁
//        lock.lock();
    //阻塞式等待。默认加锁30s时间
    //1)、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s。不用担心业务时间长，锁自动过期删掉
    //2)、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s 以后自动删除

    lock.lock(10, TimeUnit.SECONDS);
    //10s钟自动解锁，自动解锁时间一定要大于业务执行时间
    //问题:lock.lock(10, TimeUnit.SECONDS); 在锁时间到了以后，不会自动续期
    //1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就 我们指定的时间
    //2、如果我们未指定超时间件，就使用 30 * 1000【LockWatchdogTimeout看门狗的 默认时间】
    // 只要占锁成功，就会启动一个定时任务。【重新给锁设置过期时间，新的过期时间就 是看门狗的默认时间】,每隔10s都会自动再次续期，续成满时间
    // internalLockLeaseTime / 3 【看门狗时间 / 3，10s】 26
    //最佳实战
    //1)、lock.lock(10, TimeUnit.SECONDS); 省掉了整个续期操作。手动解锁
    try {
        System.out.println("加锁成功，执行业务..." + Thread.currentThread().getId());
        Thread.sleep(60000);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        //3、解锁 假设解锁代码没有运行，redisson会不会出现问题
        System.out.println("释放锁..." + Thread.currentThread().getId());
        lock.unlock();
//            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
//                lock.unlock();
//            }
    }
    return "hello";
}

• 4)读锁示例

@ResponseBody
@GetMapping("/read")
public String readValue() {
    RReadWriteLock lock = redisson.getReadWriteLock("rw‐lock");
    String s = "";
    //加读锁
    RLock rLock = lock.readLock();
    rLock.lock();
    System.out.println("读锁加锁成功..." + Thread.currentThread().getId());
    try {
        Thread.sleep(30000);
        s = redisson.getBucket("writeValue").toString();
    } catch (Exception e) {
        e.printStackTrace();

    } finally {
        rLock.unlock();
        System.out.println("读锁释放..." + Thread.currentThread().getId());
    }
    return s;
}

• 5)写锁示例

//保证一定能读到最新数据，修改期间，写锁是一个排他锁(互斥锁，独享锁)。读锁是 一个共享锁
//写锁没释放，读就必须等待
//读 + 读，相当于无锁，并发读，只会在redis中记录好，所有当前的读锁，他们都会时加锁成功
//写 + 读，等待写锁释放
//写 + 写，阻塞方式是同
//读 + 写，有读锁，写也需要等待
//只要有写的存在，都必须等待
@ResponseBody
@GetMapping("/write")
public String writeValue() {
    RReadWriteLock lock = redisson.getReadWriteLock("rw‐lock");
    String s = "";
    RLock rLock = lock.writeLock();
    //1、改数据加写锁，读数据加读锁
    rLock.lock();
    System.out.println("写锁加锁成功..." + Thread.currentThread().getId());
    try {
        s = UUID.randomUUID().toString();
        Thread.sleep(30000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
        System.out.println("写锁释放..." + Thread.currentThread().getId());
    }
    return s;
}

四、Redisson、Jedis、Lettuce优缺点对比

Redisson

• 优点：
  实现了分布式特性和可扩展的 Java 数据结构，适合分布式开发；
  API线程安全；
  基于Netty框架的事件驱动的通信，可异步调用。
• 缺点：
  API更抽象，学习使用成本高。

Jedis

• 优点：
  提供了比较全面的Redis操作特性的API
  API基本与Redis的指令一一对应，使用简单易理解。
• 缺点:
  同步阻塞IO；
  不支持异步；
  线程不安全。

Lettuce

• 优点：
  线程安全;
  基于Netty 框架的事件驱动的通信，可异步调用;
  适用于分布式缓存。
• 缺点：
  API更抽象，学习使用成本高。

其中Jedis是用的最普遍的，Spring的RedisTemplate用的就是Jedis，适用很多单体应用或者伪分布式应用等；而Redisson更多应用于分布式场景，更强大，更可靠，作为分布式锁的选择，和zookeeper有着一样的地位。