java分布式&锁&分布式锁

本文介绍: ☆动态配置，这个配置是可以轻松的跟新的，把配置写到数据库，Redis，配置中心（Na cos，Apollo，spring Cloud config）（问题：如果服务器数据太多，ip不可控制）配置，写死配置，每个服务器都执行定时任务，但是只有ip符合配置的才真实执行业务逻辑，其他的直接返回。分离定时任务，把控制定时任务从主程序中拆开（成本太大）分布式锁【只有抢到锁的服务器才能执行定时任务】

java分布式&锁&分布式锁

锁

锁的作用：有限资源的情况下，控制同一时间段，只有某些线程（用户/服务器）能访问到资源。
锁在java中的实现：
- synchronized关键字
- 并发包的类
缺点：只对单个的jvm有效

分布式锁

为什么实现分布式锁
- 有限资源的情况下，控制同一段时间只有某些用户/服务器才能访问到资源
- 单个锁只对单个jvm有效
分布锁实现（核心思想，先来server把数据改成自己的标识，后来的人发现标识已经存在就等待）
- 抢锁机制 ==> 同一时间只有一个服务器能抢到资源 ==>
  1. Mysql数据库实现，数据库中有一个字段标识锁，哪个服务器先到达数据库，就将此标识改为自己服务器的值，下一个服务器查到达查看不为空就等待，知道此上一个服务器用完，将标识位改为空时，方可用。
    - 查select（控制只有一个服务器在查）（1.select for update 行级锁，2.乐观锁）
    - 改update
  2. redis实现，存标识。读写速度快，支持setnx，lua脚本实现
    - 原理：使用 redis的setnx方法保证原子性质
      setnx:set if not exist如果不存在，则设置，只有设置成功才会返回 true，否则返回 false
    - 注意1：用完锁之后要释放，防止在释放之前服务器出现意外，因此要设置过期时间
    - 注意2：如果方法执行时间过长，锁提前过期，出现多个服务器同时执行。=> 续期（redisson中提供续期机制，原理：监听当前线程，默认过期时间是30s，每10s续期一次（补充到30s），如果线程挂了，则不会续期，如果debug 模式也会被当成服务器宕机）。
    - 注意3：连锁效应：释放了其他server的锁 .=> 判断如果不是我的锁就不释放
    - 注意4：释放锁的时候，有可能先判断出是自己的锁，但是这时候锁过期了，会释放其他服务器/用户的锁 => 判断和释放的时候不允许其他任何的方法进入，redis原子性操作。配合redis+lua 脚本。
1. Zookeeper实现

控制定时 任务的执行（在同一时间只有一个服务器能执行）

原因：
- 浪费资源，假设有1000台服务器同时工作
- 脏数据
实现方式
1. 分离定时任务，把控制定时任务从主程序中拆开（成本太大）
2. 配置，写死配置，每个服务器都执行定时任务，但是只有ip符合配置的才真实执行业务逻辑，其他的直接返回。
3. ☆动态配置，这个配置是可以轻松的跟新的，把配置写到数据库，Redis，配置中心（Na cos，Apollo，spring Cloud config）（问题：如果服务器数据太多，ip不可控制）
4. 分布式锁【只有抢到锁的服务器才能执行定时任务】

Reddisson实现 分布式锁

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

Redisson使用方法

支持springboot整合Rdisson，写配置，默认整合客户端。（版本迭代太快）

只引入Redisson，自己创建客户端

引入项目依赖Redisson类库

 <!--https://github.com/redisson/redisson#quick-start--&gt;
        <dependency&gt;
            <groupId&gt;org.redisson</groupId&gt;
            <artifactId>redisson</artifactId>
            <version>3.21.3</version>
        </dependency>

新建 redisson客户端

/**
 * redisson配置
 */
@Configuration
@ConfigurationProperties(prefix = "spring.redis")
@Data
public class RedissonConfig {
    private String host;
    private String port;

    @Bean
    public RedissonClient redissonClient(){
        // 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;
    }
}

使用锁实现缓存预热
waitTime = 0 只抢一次

/**
 * 缓存预热任务
 */
@Slf4j
public class PreCacheJob {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    private UserService userService;

    @Resource
    public UserMapper userMapper;

    //重点用户
    private List<Long> mainUserList = Arrays.asList(1L);
    //引入redisson客户端
    @Resource
    private RedissonClient redissonClient;

    //每天执行，预热推荐用户
    @Scheduled(cron = "0 31 19 * * ? ")
    public void doCacheRecommendUser() {
        RLock lock = redissonClient.getLock("yupao:precachejob:docache:lock");
        try {
            //waitTime:其他线程等待的时间，因为我们缓存预热每天只做一次，所以只要有一个线程拿到锁就
            //leaseTime：锁过期时间
            if (lock.tryLock(0, 30000L, TimeUnit.MILLISECONDS)) {//是否拿到锁
                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();
            }
        }
    }
}