分布式锁原理及实现

目录

一、锁的使用场景

二、如何实现控制？

三、单台服务器使用锁的场景

四、分布式锁

五、Redis 实现分布式锁及存在问题

六、Redisson 实现分布式锁

七、定时任务＋锁

---

一、锁的使用场景

1. 控制定时任务执行

• 定时任务多次执行浪费资源：多台服务器到同一时间都执行缓存预热
• 脏数据：多台服务器重复插入数据

2. 买票场景

• 只有一百张票，用户买票时判断剩余票的数量，还有剩余执行票数减一的操作
• 只剩一张票了，此时多个用户来买票，判断票都是有剩余，但是第一个用户买完之后就没票了，其他用户也执行了票数减一的操作，出现超卖现象

3. 需求：控制定时任务 / 需要加锁的任务在同一时间只能有一台服务器执行

二、如何实现控制？

以定时任务为例

1.?分离定时任务程序和主程序，只在一台服务器运行定时任务=>成本太大

2.?写死配置，每个服务器都执行定时任务，但是只有 IP?符合配置的服务器才真实执行业务逻辑，其他的直接返回。成本最低；但是我们的 IP 可能是不固定的，把 IP 写的太死了

3.?动态配置，配置是可以轻松的、很方便地更新的（代码无需重启，项目无需重新部署），但是只有 IP?符合配置的服务器才真实执行业务逻辑。

• 读取数据库中的配置

• Redis

• 配置中心（Nacos、Apollo、Spring Cloud Config）

• 问题：服务器多了、IP 不可控还是很麻烦，还是要人工修改

4.?分布式锁：只有抢到锁的服务器才能执行业务逻辑

• 坏处：增加成本
• 好处：不用手动配置，多少个服务器都一样

三、单台服务器使用锁的场景

1. Java 实现同步锁：synchronized 关键字

2. 锁存在 JVM 中，每台 JVM 独立，不共享锁，多机部署锁会失效（多个线程都会获取到不同 JVM 中的同一名称的锁）

3. 单机就会存在单点故障

四、分布式锁

1. 为什么需要分布式锁？

• 普通锁的缺点：JVM 机分配的锁在多台 Tomcat 中不共享，锁只对单个服务器有效
• 加锁的重要性：资源有限 / 特定情况下只能有有限 / 唯一的线程获取到锁，执行操作
• 分布式锁：多进程可见且并且互斥的锁

2. 如何实现分布式锁？

实现分布式锁的核心思想 /?怎么保证同一时间只有一台服务器能抢到锁？

• 先来的人先把数据改成自己的标识（服务器 IP），后来的人发现标识已存在，就抢锁失败，继续等待
• 等先来的人执行方法结束，把标识清空（释放锁），其他的人继续抢锁

• MySQL 数据库：select for update 行级锁（最简单）
• 乐观锁（实际上没有加锁）：乐观锁认为线程安全问题只在少数情况下会发生，所以只要在数据更新时判断是否有其他线程修改了数据
• Redis 实现互斥锁：基于内存，读写速度快
  • set nx ex：原子性、设置过期时间
  • lua 脚本：保证多条语句的原子性
• Zookeeper

五、Redis 实现分布式锁及存在问题（误删锁）

1. set nx ex

2. 释放锁

• 手动释放：del lock
• 意外：服务器宕机，手动释放锁还未执行
• 优化：设置过期时间，若未手动释放则等到过期时间到了就会自动释放锁

3. 误删锁

• 线程 A 在执行时阻塞，过了锁的过期时间，锁自动释放
• 线程 B 尝试获取锁，获取成功，执行业务
• A 阻塞之后继续执行，执行结束，释放当前正在被线程 B 占有的锁
• 线程 C 尝试获取锁，获取成功，执行业务
• 出现线程 B 和线程 C 并发执行的情况

4. 解决误删锁

• 判断当前锁的占有线程是不是本线程
• 如果不是自己占有的锁，就不去释放（别人的锁）

5. 改进锁之后仍然存在问题：判断锁和释放锁的原子性问题

• 判断锁时是自己正在占有锁
• 判断锁标识后，执行释放锁之前，线程出现了阻塞，锁到了过期时间，自动释放
• 其他线程尝试获取锁，获取成功
• 阻塞之后执行释放锁，还是把别人的锁给释放了
• 需要保证判断锁和释放锁操作的原子性：Lua 脚本

六、Redisson 实现分布式锁

Github：https://github.com/redisson/redisson

官网：Redisson: Easy Redis Java client with features of In-Memory Data Grid

1. 定义

• Redisson 是一个在 Redis 基础上实现的 Java 驻内存数据网格
• 提供了一系列分布式的 Java 常用对象，还提供了许多分布式服务（各种分布式锁的实现）

2. 自己编写 Redisson 的配置，创建 RedissonClient

• 不推荐使用 spring-boot-starter 整合的 Redisson，版本迭代较快，容易发生冲突
• 创建 config 对象，添加 Redis 配置：读取 application.yml 中的配置信息
• 创建 Redisson 实例，返回 Redisson 客户端实例

/**
 * Redisson 配置
 * @author 乐小鑫
 * @version 1.0
 * @Date 2024-01-21-15:44
 */
@Configuration
@ConfigurationProperties(prefix = "spring.redis")
@Data
public class RedissonConfig {

    private String host;

    private String port;

    private String password;

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

3. 测试 Redisson 的功能实现

/**
 * @author 乐小鑫
 * @version 1.0
 * @Date 2024-01-21-15:53
 */
@SpringBootTest
public class RedissonTest {

    @Resource
    private RedissonClient redissonClient;

    @Test
    void test() {
        // list
        List<String> list = new ArrayList<>();
        list.add("ghost");
        System.out.println("List:" + list.get(0));
        RList<Object> rList = redissonClient.getList("test-list");
        rList.add("ghost");
        System.out.println("rList:" + rList.get(0));
    }
}

?

七、定时任务＋锁

1. getLock()：获取 Redisson 的锁对象，需要指定锁的名称

2. tryLock()：尝试获取锁（分布式锁），获取成功返回 true，可以指定重试获取锁的等待时间和锁的释放时间

3. unlock()：释放锁，放到 finally 语句块中执行，如果 try 语句块中的内容出现异常，也会释放锁，避免发生死锁的情况

/**
 * 缓存预热定时任务
 * @author 乐小鑫
 * @version 1.0
 */
@Component
@Slf4j
public class PreCacheUser {

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private UserService userService;

    @Resource
    private RedissonClient redissonClient;

    List<Long> mainUserList = Arrays.asList(3L);// 重要用户列表，为该列表的用户开启缓存预热

    @Scheduled(cron = "0 59 21 ? * * ")// 每天 21:59 执行定时任务进行用户数据缓存预热
    public void doPreCacheUser() {
        // 获取锁对象
        RLock lock = redissonClient.getLock("langhua:precachejob:doprecache:lock");
        try {
            if (lock.tryLock(0,30000L,TimeUnit.MILLISECONDS)) {
                log.info("get redisson lock" + Thread.currentThread().getId());
                // 查出用户存到 Redis 中
                for (Long userId : mainUserList) {
                    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
                    Page<User> userPage = userService.page(new Page<>(1, 20), queryWrapper);// 查询所有用户
                    String key = String.format("langhua:user:recommend:%s", userId);
                    ValueOperations valueOperations = redisTemplate.opsForValue();
                    // 将查询出来的数据写入缓存
                    try {
                        valueOperations.set(key,userPage,24, TimeUnit.HOURS);
                    } catch (Exception e) {
                        log.error("redis key set error", e);
                    }
                }
            }
        } catch (InterruptedException e) {
            log.error("redisson precache user error", e);
        } finally {
            // 释放锁
            log.info("redisson unlock" + Thread.currentThread().getId());
            lock.unlock();
        }

    }
}