心链8-----锁的实现及Redission实现分布式锁（看门狗机制）

2024-06-06 12:32:02
开发
7

心链 — 伙伴匹配系统

概念

控制定时任务的执行（为啥？）

浪费资源，想象 10000 台服务器同时 “打鸣”
脏数据，比如重复插入

**要控制定时任务在同一时间只有 1 个服务器能执行。（**怎么做？）

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

单机就会存在单点故障。

:::

锁

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

分布式锁

为啥需要分布式锁？

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

【分布式锁】三种分布式锁的实现【原创】_defaultvalueoperations set-CSDN博客

分布式锁实现的关键

抢锁机制

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

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

MySQL 数据库：select for update 行级锁（最简单）
（乐观锁）
✔ Redis 实现：内存数据库，读写速度快 。支持 setnx、lua 脚本，比较方便我们实现分布式锁。
setnx：set if not exists 如果不存在，则设置；只有设置成功才会返回 true，否则返回 false。

注意事项

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

boolean end = false;

//线程
new Thread(() -> {
    //判断状态
    if (!end)}{
        续期
    })

    end = true;

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

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

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

Redis + lua 脚本实现
https://blog.csdn.net/feiying0canglang/article/details/113258494

Redission 实现分布式锁

Java 客户端，数据网格
实现了很多 Java 里支持的接口和数据结构

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

spring boot starter 引入（不推荐，版本迭代太快，容易冲突）https://github.com/redisson/redisson/tree/master/redisson-spring-boot-starter
直接引入： Quick start(快速开始)

GitHub - redisson/redisson: Redisson - Easy Valkey/Redis Java client and Real-Time Data Platform. Sync/Async/RxJava/Reactive API. Over 50 Redis based Java objects and services: Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Spring Cache, Tomcat, Scheduler, JCache API, Hibernate, RPC, local cache …
添加依赖,编写RedissonConfig文件。然后是对Redisson的测试，对Redis数据进行增删改。

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


/**
 * 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);
        //  使用单个Redis，没有开集群 useClusterServers()  设置地址和使用库
        config.useSingleServer().setAddress(redisAddress).setDatabase(3);
        // 2. 创建实例
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }
}


@SpringBootTest
public class RedissonTest {

    @Resource
    private RedissonClient redissonClient;

    @Test
    void test() {
        // 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);

        // map
        Map<String, Integer> map = new HashMap<>();
        map.put("yupi", 10);
        map.get("yupi");

        RMap<Object, Object> map1 = redissonClient.getMap("test-map");

        // set

        // stack


    }
}

分布式锁的实现

定时任务 + 锁

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

/**
 * @author: shayu
 * @date: 2022/12/11
 * @ClassName: yupao-backend01
 * @Description: 数据预热
 */

@Component
@Slf4j
public class PreCacheJob {

    @Resource
    private UserService userService;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

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

    // 每天执行，预热推荐用户
    @Scheduled(cron = "0 12 1 * * *")   //自己设置时间测试
    public void doCacheRecommendUser() {
        RLock lock = redissonClient.getLock("shayu: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("shayu:user:recommend:%s", mainUserList);
                    ValueOperations valueOperations = redisTemplate.opsForValue();
                    //写缓存,30s过期
                    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();
            }
        }

    }
}

测试

测试一下分布式，三个服务程序争抢锁（这里指缓存数据查询程序）。
（提醒：我们这里是用定时任务触发抢锁，所以定时任务时间先设定好，大概延后几分钟就行，下面的操作包括设定定时任务时间—打包—启动三个服务—到时间抢锁其中一个服务抢到锁控制台回馈）

maven-package打包，生成target文件。cd进去相应文件夹。
在使用Java命令设置端口启动项目。java -jar .\yupao-backend-0.0.1-SNAPSHOT.jar --server.port=8081（8081端口）；开启三个服务。

测试只有一个能抢到锁
成功！！！！！

看门狗机制（逾期问题）

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

原理：

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

Redisson 分布式锁的watch dog自动续期机制_redisson续期-CSDN博客

    @Test
    void testWatchDog() {
        RLock lock = redissonClient.getLock("sanshui:precachejob:docache:lock");
        try {
            // 只有一个线程能获取到锁
            if (lock.tryLock(0, -1, TimeUnit.MILLISECONDS)) {
                Thread.sleep(300000);//todo 实际要执行的代码
                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();
            }
        }
    }

思考

Redisson和spring-data-redis的区别？
之前在使用spring-data-redis时（第7章中），他也是可以对Redis进行操作。而Redisson也可对Redis进行操作。他们之间区别在哪，或者说侧重在哪。我当时想到的是Redisson可以对Redis集群操作。有兴趣的可以自己搜搜一下。
redission-CSDN博客
 spring-data-redis概述及用法_spring data redis-CSDN博客

原文地址:https://blog.csdn.net/PQ781826/article/details/139411734 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1798573537783582720.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部