控制定时任务的执行

1. 浪费资源，想象 10000 台服务器同时执行定时任务
2. 脏数据，比如重复插入数据

要控制定时任务在同一时间只有 1 个服务器能执行。

怎么做？

1. 分离定时任务程序和主程序，只在 1 个服务器运行定时任务，其他服务器crud。成本太大
2. 写死配置，每个服务器都执行定时任务，但是只有 ip 符合配置的服务器才真实执行业务逻辑，其他的直接返回。成本最低；但是我们的 IP 可能是不固定的，把 IP 写的太死了
3. 动态配置，配置是可以轻松的、很方便地更新的（ 代码无需重启 ），但是只有 ip 符合配置的服务器才真实执行业务逻辑。
4. 数据库
5. Redis
6. 配置中心（Nacos、Apollo、Spring Cloud Config）
7. 问题：服务器多了、IP 不可控还是很麻烦，还是要人工修改
8. 分布式锁，只有抢到锁的服务器才能执行业务逻辑。坏处：增加成本；好处：不用手动配置，多少个服务器都一样。

服务器相当于人，打一架，谁赢了，谁执行

单机就会存在单点故障。

有限资源的情况下，控制同一时间（段）只有某些线程（用户 / 服务器）能访问到资源。

Java 实现锁：synchronized 关键字、并发包的类

只对单个 JVM 有效

分布式锁

为啥需要分布式锁？

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

分布式锁实现的关键

抢锁机制

怎么保证同一时间只有 1 个服务器能抢到锁？

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

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

MySQL 数据库：select for update 行级锁（最简单）

（乐观锁）

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

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

之后无论怎么设置，都只会是第一个存入的

注意事项

1. 用完锁要释放（腾地方）√
2. 锁一定要加过期时间 √
3. 如果方法执行时间过长，锁提前过期了？
4. 3的问题：
1. 连锁效应：释放掉别人的锁
2. 这样还是会存在多个方法同时执行的情况

解决方案：续期

boolean end = false;

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

end = true;

4. 释放锁的时候，有可能先判断出是自己的锁，但这时锁过期了，最后还是释放了别人的锁
5. A判断是自己的锁，结果过期了，然后b见缝插针给加锁，A删的就是b的锁了
6. // 原子操作 if(get lock == A) { // set lock B del lock }
7. Redis + lua 脚本实现
8. Redis 如果是集群（而不是只有一个 Redis），如果分布式锁的数据不同步怎么办？

? 红锁

https://blog.csdn.net/feiying0canglang/article/details/113258494

拒绝自己写！！！

Redisson 实现分布式锁

Java 客户端，数据网格

实现了很多 Java 里支持的接口和数据结构

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

2 种引入方式

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

导入依赖

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

配置类

package com.bo.partner.config;

import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author: bo
 * @date: 2022/9/14
 * @description:
 */
@Configuration
@ConfigurationProperties(prefix = "spring.redis")
@Data
public class RedissonConfig {
    private String host;
    private String port;

    @Bean
    public RedissonClient redisClient() {
        // 1.创建配置
        Config config = new Config();
        String redisAddress = String.format("redis://%s:%s",host,port);
        config.useSingleServer().setAddress(redisAddress).setDatabase(3);
        // 2.创建实例
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }

}

@ConfigurationProperties(prefix = "spring.redis") 读取了yml的配置

测试一下

@SpringBootTest
public class RedissonTest {
    @Resource
    private RedissonClient redissonClient;
    @Test
    void set() {
        //list
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.get(0);
        /*list.remove(0);*/
        System.out.println("list"+list.get(0));

        RList<Object> rList = redissonClient.getList("test-list");
        rList.add("bb");
        rList.get(0);
        /*rList.remove(0);*/
        System.out.println("rlist"+rList.get(0));
    }
}

为什么redisson和本地的list一模一样的，点进去看

继承了List接口

定时任务 + 锁

1. waitTime 设置为 0，只抢一次，抢不到就放弃
2. 注意释放锁要写在 finally 中

如果程序报错直接抛异常，就不会执行释放锁了，所以要放到finally里

@Component
@Slf4j
public class PreCacheJob {

    private List<Long> mainUserList = Arrays.asList(1L);
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    private UserService userService;
    @Resource
    private UserMapper userMapper;
    @Resource
    private RedissonClient redissonClient;

    @Scheduled(cron = "0 42,46 * * * *")
    public void doCatchRecommendUser() {
        //实现了只有一共线程能获取到锁
        //获取锁对象
        RLock lock = redissonClient.getLock("partner:precachejob:docache:lock");
        //写锁
        try {
            if( lock.tryLock(0,30000,TimeUnit.MILLISECONDS)){
           		 //todo     
            }
        } catch (InterruptedException e) {
            log.error("doCatchRecommendUser error", e);
        }finally {
            //查看是自己加的锁吗,是自己的锁再释放
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

解决续期问题

看门狗机制

redisson 中提供的续期机制

开一个监听线程，如果方法还没执行完，就帮你重置 redis 锁的过期时间。

原理：

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

https://blog.csdn.net/qq_26222859/article/details/79645203

打2个输出

用idea启动多个实例

ctrl+D复制一个实例

每10s续一次

为什么默认续期是30s

防止宕机

实现代码

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();
        }
    }
}