分布式锁

为什么需要分布式锁

1.有限资源的情况下，控制同一时间（段）只有某些线程（用户/服务器）能访问到资源。 2.单个锁只对单个JVM有效

抢锁机制

核心思想：先来的人先把数据改成自己的标识（服务器ip），后来的人发现标识已存在，就抢锁失败，继续等待。

等先来的人执行方法结束，把标识清空，其他的人继续抢锁。

MySQL数据库：select for update行级锁（最简单），或者用乐观锁。

✔Redis实现：内存数据库，读写速度快。支持setnx、lua脚本，比较方便我们实现分布式锁。

setnx:set if not exists如果不存在，则设置；只有设置成功才会返回true,否则返回false。

注意事项

用完锁要释放（腾地方）
锁一定要加过期时间
如果方法执行时间过长，锁提前过期了？
- 会导致问题：
  1. 连锁效应：释放掉别人的锁
    - 比如小A此时执行一个方法需要40秒，但是锁只有30秒的时间，此时锁的时间结束了，小B进来了，但是此时小A的方法执行结束了，会释放当前小B上的锁
  2. 这样还是会存在多个方法同时执行的情况
  3. 解决方案：续期

boolean end = false;

new Thread(() -> {
    if (!end)}{
    续期
})

end = true;

4.释放锁的时候，有可能先判断出是自己的锁，但这时锁过期了，最后还是释放了别人的锁

比如此时程序刚判断完得到的锁是A，然后锁失效了，B进来了，然后把B的锁del了，此时C就上锁了

if(get lock == A){
    当前位置
    del lock
}

解决方法：Redis+lua脚本保证操作原子性

// 原子操作
if(get lock == A){
    // set lock B
    del lock
}

5.Redis如果是集群（而不是只有一个redis），如果分布式锁的数据不同步怎么办？

Redisson实现分布式锁

Redisson是一个java操作Redis的客户端，提供了大量的分布式数据集来简化对Redis的操作和使用，可以让开发者像使用本地集合一样使用Redis,完全感知不到Redis的存在。

2种引入方式

spring boot starter引入（不推荐，版本迭代快）：https://github.com/redisson/redisson/tree/master/redisson-spring-boot-starter
直接引入：https://github.com/redisson/redisson#quick-start

使用Redisson

// list，数据存在本地 JVM 内存中
List<String> list = new ArrayList<>();
list.add("yupi");
System.out.println("list:" + list.get(0));

list.remove(0);

// 数据存在 redis 的内存中
RList<String> rList = redissonClient.getList("test-list");
rList.add("yupi");
System.out.println("rlist:" + rList.get(0));
rList.remove(0);

分布式锁保证定时任务不重复执行

void testWatchDog() {
    RLock lock = redissonClient.getLock("yupao:precachejob:docache:lock");
    try {
        // 只有一个线程能获取到锁
        if (lock.tryLock(0, -1, TimeUnit.MILLISECONDS)) {
            // todo 实际要执行的方法
            doSomeThings();
            System.out.println("getLock: " + Thread.currentThread().getId());
        }
    } catch (InterruptedException e) {
        System.out.println(e.getMessage());
    } finally {
        // 只能释放自己的锁
        if (lock.isHeldByCurrentThread()) {
            System.out.println("unLock: " + Thread.currentThread().getId());
            lock.unlock();
        }
    }
}

Redission看门狗机制

redission中提供的续期机制

一个线程中，如果方法还没有执行完，会重置redis过期时间。

Redission实现多个服务器定时刷新用户

释放锁的时刻要在finally中执行，因为你执行的业务可能会挂，这样就不会释放锁

    public void doCacheRecommendUser() {
        RLock lock = redissonClient.getLock("yupao:precachejob:docache:lock");
        try {
            // 只有一个线程能获取到锁
            if (lock.tryLock(0, -1, TimeUnit.MILLISECONDS)) {
                System.out.println("getLock: " + Thread.currentThread().getId());
                for (Long userId : mainUserList) {
                    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
                    Page<User> userPage = userService.page(new Page<>(1, 20), queryWrapper);
                    String redisKey = String.format("yupao:user:recommend:%s", userId);
                    ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
                    // 写缓存
                    try {
                        valueOperations.set(redisKey, userPage, 30000, TimeUnit.MILLISECONDS);
                    } catch (Exception e) {
                        log.error("redis set key error", e);
                    }
                }
            }
        } catch (InterruptedException e) {
            log.error("doCacheRecommendUser error", e);
        } finally {
            // 只能释放自己的锁
            if (lock.isHeldByCurrentThread()) {
                System.out.println("unLock: " + Thread.currentThread().getId());
                lock.unlock();
            }
        }
    }

目录CONTENT

锁-控制同一只有某些线程（用户/服务器）能访问资源