黑马程序员Java面试专题（1）|常见集合篇（1）ArrayList&LinkedList

锁

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

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

问题：只对单个 JVM 有效

分布式锁

当前系统每天凌晨四点服务器预热缓存

若采取分布式多台服务器,则会进行多次预热缓存
导致定时任务重复执行

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

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

1. 分离定时任务程序和主程序，只在 1 个服务器运行定时任务。成本太大
2. 写死配置，每个服务器都执行定时任务，但是只有 ip 符合配置的服务器才真实执行业务逻辑，其他的直接返回。成本最低；但是我们的 IP 可能是不固定的，把 IP 写的太死
3. 动态配置，配置是可以轻松的、很方便地更新的（代码无需重启），但是只有 ip 符合配置的服务器才真实执行业务逻辑。问题：服务器多了、IP 不可控还是很麻烦，还是要人工修改

• 数据库
• Redis
• 配置中心（Nacos、Apollo、Spring Cloud Config）

4. 分布式锁，只有抢到锁的服务器才能执行业务逻辑。坏处：增加成本；好处：不用手动配置，多少个服务器都一样。

单机就会存在单点故障。

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

分布式锁实现的关键

抢锁机制

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

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

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

2. （乐观锁）

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

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

注意事项

1. 用完锁要释放（腾地方）√

2. 锁一定要加过期时间 √(如果服务器挂了,仍能释放锁)

3. 如果方法执行时间过长，锁提前过期了？问题：

4. 连锁效应：释放掉别人的锁

5. 这样还是会存在多个方法同时执行的情况

解决方案：续期

boolean end = false;

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

    end = true;

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

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

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

Redis + lua 脚本实现

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

Redisson 实现分布式锁

redissson

Java 客户端，数据网格
实现了很多 Java 里支持的接口和数据结构
Redisson 是一个 java 操作 Redis 的客户端，提供了大量的分布式数据集来简化对 Redis 的操作和使用，可以让开发者像使用本地集合一样使用 Redis，完全感知不到 Redis 的存在。

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

https://github.com/redisson/redisson#quick-start

添加依赖,编写RedissonConfig文件。然后是对Redisson的测试，对Redis数据进行增删改。

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

@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


    }
}

Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘redissonClient’ defined in class path resource [com/calmthinker/youjian/config/RedissonConfig.class]: Bean instantiation via factory method failed; nested exception is org.springframework.beans

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

也不知道为什么,哎

分布式锁的实现

定时任务 + 锁

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

@Resource  
private UserService userService;  
  
@Resource  
private RedisTemplate<String, Object> redisTemplate;  
  
@Resource  
private RedissonClient redissonClient;  
// 重点用户  
private List<Long> mainUserList = Arrays.asList(1L);  
  
// 每天执行，预热推荐用户  
@Scheduled(cron = "0 4 0 * * *") //自己设置时间测试  
public void doCacheRecommendUser() {  
// 分布式锁，防止并发执行  
RLock lock = redissonClient.getLock("youjian: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, 8), queryWrapper);  
String redisKey = String.format("youjian: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端口）；开启三个服务。

我这里是8083端口服务抢到了锁。我这里是缓存过期了，所以没有数据。OK

看门狗机制（逾期问题）

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

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

    @Test
    void testWatchDog() {
        RLock lock = redissonClient.getLock("yupao: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();
            }
        }
    }