Redis分布式锁

分布式锁执行流程

实现分布式锁时需要实现的两个基本方法：

获取锁：

互斥：确保只能有一个线程获取锁
非阻塞：尝试一次，成功返回true，失败返回false

# 添加锁，NX是（if not exist）只有该键不存在才set成功否则set失败，EX是设置超时时间
SET lock thread NX EX 10

释放锁：

手动释放
超时释放：获取锁时添加一个超时时间

# 释放锁，删除即可
DEL key

分布式锁初级版本

public interface ILock {

    /**
     * 非阻塞方式，尝试获取锁
     * @param timeoutSec 锁持有的超时时间，过期后自动释放
     * @return true代表获取锁成功; false代表获取锁失败
     */
    boolean tryLock(long timeoutSec);

    /**
     * 释放锁
     */
    void unlock();
}

public class SimpleRedisLock implements ILock {

	// 业务名称
    private String name;
    private StringRedisTemplate stringRedisTemplate;

	// 通过构造方法将name和stringRedisTemplate传入
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";

    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取线程标识
        long threadId = Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        //通过del删除锁
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

Redis分布式锁误删问题

误删第一种情况如图上

1. 线程1获得了锁但是业务发生了阻塞，一直阻塞到该锁自动释放
2. 释放后线程2获得了锁开始执行业务，此时线程1不再阻塞业务开始执行
3. 线程1业务先于线程2完成并释放锁，此时线程1释放的是线程2的锁，
4. 线程2的锁被线程1释放后线程3再次获得锁执行业务引发类似的线程不安全问题

解决第一种误删问题

在获得锁的时候存入线程标识可以用（UUID）表示

在释放锁时先获取锁中的线程标识，判断是否与当前线程标识一致

• 如果一致则释放锁
• 如果不一致则不释放锁
• 注意：不要直接将线程id作为线程标识，因为不同JVM中的线程id可能一样，所以可以用 线程id+UUID 作为线程标识

public class SimpleRedisLock implements ILock {

    // 业务名称
    private String name;
    private StringRedisTemplate stringRedisTemplate;

    // 通过构造方法将name和stringRedisTemplate传入
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";

    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        // 获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁中的标识
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        // 判断标识是否一致
        if(threadId.equals(id)) {
            // 释放锁
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }
}

误删第二种情况如图上

1. 线程1获得了锁开始执行业务,再执行到unlock方法中的时候，获取了锁标识，并判断了是一致的
2. 即以及进入到if条件判断里面此时由于某种原因发生了阻塞，阻塞到线程1的锁超时释放，线程2获得了锁。
3. 此时在线程2执行业务的时候，线程1不再阻塞即要删除线程1的锁，但此时删除的为线程2的锁这再次造成了线程不安全问题。

解决第二种误删问题

第二种误删问题本质是原子性问题unlock方法不是原子性操作，可通过lua脚本实现
此时区分两个概念数据库的原子性操作是要么都成功要么都失败，并发编程中指的原子性是，操作不可拆分、不被中断 举例来说，当前unlock方法有两redis命令操作，给redis执行的时候是两个任务在任务队列中，中间可能有其他的任务，此时不是原子性的，而经过lua脚本编程实现的这两条命令被封装成了一个任务给redis执行，中间不会插入任何其他的任务，因此解决了此时的误删问题。

并发执行问题

假设当前线程1执行业务时间过长导致了锁超时自动释放，而线程2此时获得了锁此时造成了并发执行的问题。

并发执行问题解决

Redission看门狗机制解决

redission中提供的续期机制
redisson 中提供的续期机制 开一个监听线程，如果方法还没执行完，就帮你重置 redis 锁的过期时间。 原理：

1. 监听当前线程，默认过期时间是 30 秒，每 10 秒续期一次（补到 30 秒）
2. 如果线程挂掉（注意 debug 模式也会被它当成服务器宕机），则不会续期

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

 @Resource
    private RedissonClient redissonClient;

    @Scheduled(cron = "0 59 23 * * *")
    public void doCacheRecommendUser() {
        RLock lock = redissonClient.getLock("friend:precachejob:docache:lock");
        try {
            if (lock.tryLock(0, 30000L, TimeUnit.MILLISECONDS)) {
                   //实际业务逻辑
                    } catch (Exception e) {
                        log.error("redis set memory error", e);
                    }
                }
            }
        } catch (Exception e) {
            log.error("doCacheCommendUser error", e);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }