初识Redission分布式锁

一、分布式锁特性

在设计分布式锁的时候，应该考虑分布式锁至少要满足的一些条件：
1、互斥：在分布式高并发的条件，同一时刻只能有一个线程获得锁，这是最基本的一点；
2、死锁：在分布式高并发的条件下，如果一个线程获得锁，然后挂了，并没有释放锁，致使其他线程永远无法获取锁，这就是死锁，分布式锁必须做到避免死锁；
3、性能：对于访问量大的共享资源，需要考虑减少锁等待的时间，避免导致大量线程阻塞。在锁的设计时，需要考虑锁的颗粒度要尽量小、锁的范围尽量要小；
4、可重入：同一个线程可以重复拿到同一个资源的锁。重入锁非常有利于资源的高效利用。

二、Redis、Redis lua脚本和Redission加锁对比

三、Redisson原理分析

1.获取锁

/**

• 尝试获取锁
• @param lockKey
• @param unit 时间单位
• @param waitTime 最多等待时间
• @param leaseTime 上锁后自动释放锁时间
• @return

*/
public static boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {

RLock lock = redissonClient.getLock(lockKey);
try {
    return lock.tryLock(waitTime, leaseTime, unit);
} catch (InterruptedException e) {
    return false;
}

}

2.释放锁

/**

• 释放锁
• @param lockKey 锁定资源

*/
public static void unlock(String lockKey) {

RLock lock = redissonClient.getLock(lockKey);
lock.unlock();

}

从上图我们可以看到Redission加锁、解锁Lua脚本是redisson分布式锁实现最重要的组成部分

3.Redission加锁Lua脚本解读

四、Redisson常用的锁

1.可重入锁（Reentrant Lock）Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁

public void testReentrantLock(RedissonClient redisson) {

RLock lock = redisson.getLock("anyLock");
try {
    // 1. 最常见的使用方法
    // lock.lock();
    // 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
    // lock.lock(10, TimeUnit.SECONDS);
    // 3. 尝试加锁，最多等待3秒，上锁以后10秒自动解锁
    boolean res = lock.tryLock(3, 10, TimeUnit.SECONDS);
    if (res) { // 成功
        // do your business
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

}

2.异步执行（Async）Redisson同时还为分布式锁提供了异步执行的相关方法

public void testAsyncReentrantLock(RedissonClient redisson) {

RLock lock = redisson.getLock("anyLock");
try {
    lock.lockAsync();
    lock.lockAsync(10, TimeUnit.SECONDS);
    Future<Boolean> res = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);
    if (res.get()) {
        // do your business
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

}

3.公平锁（Fair Lock）Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。在提供了自动过期解锁功能的同时，保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。

public void testFairLock(RedissonClient redisson){

RLock fairLock = redisson.getFairLock("anyLock");  
try{  
    // 最常见的使用方法  
    fairLock.lock();  
    // 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁  
    fairLock.lock(10, TimeUnit.SECONDS);  
    // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁  
    boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);  
    if (res) {
        // do your business
    }
} catch (InterruptedException e) {  
    e.printStackTrace();  
} finally {  
    fairLock.unlock();  
}  

}

4.联锁（MultiLock）Redisson的RedissonMultiLock对象可以将多个RLock对象关联为一个联锁，每个RLock对象实例可以来自于不同的Redisson实例

public void testMultiLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){

RLock lock1 = redisson1.getLock("lock1");  
RLock lock2 = redisson2.getLock("lock2");  
RLock lock3 = redisson3.getLock("lock3");  
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);  
try {  
    // 同时加锁：lock1 lock2 lock3, 所有的锁都上锁成功才算成功。  
    lock.lock();  
    // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁  
    boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);  
    if (res) {
        // do your business
    }
} catch (InterruptedException e) {  
    e.printStackTrace();  
} finally {  
    lock.unlock();  
}  

}

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

public void testRedLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){

RLock lock1 = redisson1.getLock("lock1");  
RLock lock2 = redisson2.getLock("lock2");  
RLock lock3 = redisson3.getLock("lock3");  
RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);  
try {  
    // 同时加锁：lock1 lock2 lock3, 红锁在大部分节点上加锁成功就算成功。  
    lock.lock();  
    // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁  
    boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);  
    if (res) {
        // do your business
    }
} catch (InterruptedException e) {  
    e.printStackTrace();  
} finally {  
    lock.unlock();  
}  

}