Redis高并发锁（三）分布式锁

- 日理万妓 2024-03-30 13:06 83阅读 0赞

在很多情况下，你的数据库不支持事务，分布式部署也使得你无法去使用JVM锁，那么这种时候，你可以考虑用分布式锁

#### 文章目录 ####

*  分布式锁
 *   *  1. 实现方式
     *  2. 特征
     *  3. 操作
     *  4. 代码改造
     *  5. 测试
 *  优化
 *   *  1. 递归改成循环
     *  2. 防止死锁
     *  3. 防误删
     *  4. LUA脚本 保证原子性
     *   *  1) EVAL基本使用
         *  2）代码实现
         *  3) 测试
     *  5 分布式可重入锁: lua脚本 + hash
     *   *  redis的hash数据结构
         *   *  1) hset
             *  2) hexists
             *  3) hincrby
         *  加锁优化为可重入
         *   *  1)写成LUA脚本
             *  2) 测试
         *  解锁优化为可重入
         *   *  1) 编写LUA脚本
             *  2）测试
         *  代码改造
         *   *  1） 代码较复杂，将lock类单独拿出来定义使用
             *  2） 工厂模式 DistributedLockClent
             *  3）DistributedRedisLock
             *  4) StockService
         *  测试
         *  uuid优化
         *   *  1) DistributedLockClient
             *  2) DistributedRedisLock
     *  6. 自动续期
     *   *  1） Timer定时器
         *  2) LUA脚本
         *  3) DistributedRedisLock
         *  4) 测试
 *  总结
 *   *  加锁
     *  解锁
     *  重试 循环/迭代

## 分布式锁 ##

### 1. 实现方式 ###

*  基于redis实现
 *  基于zookeeper/etcd实现
 *  基于mysql实现

### 2. 特征 ###

(1) 独占排他使用 setnx

(2) 防死锁发生：  
redis客户端获取到锁后，立马宕机（设置失效时间）  
不可重入：可重入

(3) 原子性：

*  获取锁和设置过期 set key value ex 3 nx
 *  判断和释放锁之间：使用 lua脚本

(4) 防误删：解铃还须系铃人，先判断再删除

(5) 可重入性：hash(key field value) + LUA脚本

(6) 自动续期：实际执行时间大于设置的失效时间  
定时任务（时间驱动Timer定时器）+ lua脚本

### 3. 操作 ###

*  加锁
 *  解锁
 *  重试：递归、循环
 *

> 简单来说，其实就类似于操作系统中的临界区-临界资源  
> 一群线程去争抢该资源
> 
> 1.  经过一道阀口，只有一个线程可以抢到钥匙
> 2.  持有钥匙的线程去执行，其他线程循环等待
> 3.  该线程执行完成，归还钥匙，下一个抢到钥匙的线程执行  
>     循环如此

那么代码上具体是如何操作呢

### 4. 代码改造 ###

@Service
    public class StockService {
        
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        public void deduct() {
        
    
            // 用排他锁
            Boolean flag = redisTemplate.opsForValue().setIfAbsent("lock", "111");
            if(Boolean.FALSE.equals(flag)){
        
                // 如果没抢到，等50ms后，接着抢
                try {
        
                    Thread.sleep(50);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                deduct();
                return;
            }
            // 如果抢到了，直接执行
    
            try{
        
                // 1。 查询库存
                String stockStr = redisTemplate.opsForValue().get("stock");
                if (!StringUtil.isNullOrEmpty(stockStr)) {
        
                    int stock = Integer.parseInt(stockStr);
                    // 2。 判断条件是否满足
                    if (stock > 0) {
        
                        // 3 更新redis
                        redisTemplate.opsForValue().set("stock", String.valueOf(stock - 1));
                    }
                }
            }finally {
        
                redisTemplate.delete("lock");
            }
        }

其实就是用一个新的redis key作为这把钥匙，

1.  某个线程成功setIfAbsent，那它就拿到了这把钥匙，其他线程只能等待
2.  该线程执行完成后，delete该key
3.  另一个成功setIfAbsent的线程拿到钥匙，开始执行

### 5. 测试 ###

![在这里插入图片描述][4d708961014a4aaf839edca0c8b1b56f.png]  
这里我直接使用了本地redis,之前连接的都是远程redis和mysql，发行并发量很低，后续都直接用本地了  
可以看出并发量很大，达到了455

![在这里插入图片描述][918aa5c78f5e4e0283d822a6ac4c7bc5.png]  
redis中库存也成功清0

## 优化 ##

### 1. 递归改成循环 ###

@Service
    public class StockService {
        
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        public void deduct() {
        
    
            while(!redisTemplate.opsForValue().setIfAbsent("lock", "111")){
        
                // 如果没抢到，等50ms后，接着抢
                try {
        
                    Thread.sleep(50);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
            // 如果抢到了，直接执行
    
            try{
        
                // 1。 查询库存
                String stockStr = redisTemplate.opsForValue().get("stock");
                if (!StringUtil.isNullOrEmpty(stockStr)) {
        
                    int stock = Integer.parseInt(stockStr);
                    // 2。 判断条件是否满足
                    if (stock > 0) {
        
                        // 3 更新redis
                        redisTemplate.opsForValue().set("stock", String.valueOf(stock - 1));
                    }
                }
            }finally {
        
                redisTemplate.delete("lock");
            }
        }

### 2. 防止死锁 ###

若抢到钥匙的线程执行过程中，redis客户端程序突然宕机，那即使重启，该钥匙也永远无法自动归还了，所以设置个过期时间

redisTemplate.opsForValue()
    .setIfAbsent("lock", "111",3,TimeUnit.SECONDS)

### 3. 防误删 ###

利用一个唯一标识，比如线程号/uuid，先判断是否是自己的再删除

String uuid = UUID.randomUUID().toString();
    redisTemplate.opsForValue()
    .setIfAbsent("lock", uuid,3,TimeUnit.SECONDS)

然后再删除的时候进行判断

// 先判断是否自己的锁，再解锁(防误删)
                if(StrUtil.equals(redisTemplate.opsForValue().get("lock"),uuid)){
        
                    redisTemplate.delete("lock");
                }

但该删除操作并不能保证判断再删除是原子性的，在高并发情况下，  
A判断成功后，属于A的key刚好失效，  
然后B拿到了锁，最后A 删掉的是B的锁。

### 4. LUA脚本 保证原子性 ###

redis单线程，执行指令遵循one-by-one。  
而LUA脚本一次性发送多个指令给redis，保证原子性。

#### 1) EVAL基本使用 ####

EVAL script numkeys key \[key …\] arg \[arg …\]  
script： lua脚本字符串  
numkeys： key列表的元素数量  
key列表：以空格分割 KEYS(index从1开始)  
arg列表：以空格分割 ARGV(index从1开始)

*  输出的不是print，而是return返回值

![在这里插入图片描述][5e940096235a4c3a918dcce35e3bc1b5.png]

*  全局变量 a = 5 (redis不允许定义全局变量）
 *  局部变量 local a = 5  
    ![在这里插入图片描述][60d899d6a5694ffe96826ea403711e25.png]
 *  分支控制  
    if 条件 then 代码块 elseif 条件 then 代码块 end  
    ![在这里插入图片描述][9391ff3ffd3a4af9b9fa5fb810ba9903.png]
 *  传递参数 KEYS\[\] ARGV\[\]  
    ![在这里插入图片描述][04098ba1d3444d3db7547f73beabaebc.png]
 *  LUA来调用redis的常见命令 get  
    ![在这里插入图片描述][c587f688af9a40379e1059220b96fc6f.png]  
    与redis的执行命令顺序一致，如果是set  
    ![在这里插入图片描述][7b3e141778de46b098a6a7f1f0590212.png]  
    非常简单，弄懂了后就可以开始使用lua脚本

> // 判断是否是自己的锁，如果是自己的锁，则执行删除操作  
> if redis.call(‘get’, ‘lock’) == uuid  
> then return redis.call(‘del’,‘lock’)  
> else return 0  
> end  
> key: lock  
> argv: uuid

整理成一句lua脚本语句

> EVAL " if redis.call(‘get’, KEYS\[1\]) == ARGV\[1\] then return redis.call(‘del’,KEYS\[1\]) else return 0 end" 1 ‘lock’ ‘1234’

简单测试一下  
![在这里插入图片描述][51c632370117410e8ce29594aab13f38.png]  
修改下，看不是自己的lock能不能删除  
![在这里插入图片描述][00ab6788b51e428f907d63ca6433e6a2.png]  
不是自己的lock，则不删除，ok

#### 2）代码实现 ####

String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                        "then return redis.call('del',KEYS[1]) " +
                        "else return 0 " +
                        "end\"";
    // 先判断是否自己的锁，再解锁(防误删)
    redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList("lock"), uuid);

注意execute参数，

new DefaultRedisScript<>(script, Boolean.class) 脚本和运行返回类型
     Arrays.asList("lock") keys列表，所有keys放在列表中
     uuid argv参数，后续参数直接,叠加

#### 3) 测试 ####

![在这里插入图片描述][72d21c7f9fb645058c68e402eb361ca6.png]  
并发可达475  
![在这里插入图片描述][05353cfceb5942a0bf36a8e175e2f4b1.png]  
redis也正常清零了，成功

### 5 分布式可重入锁: lua脚本 + hash ###

可参考[ReentrantLock可重入锁解析][ReentrantLock]锁实现分布式可重入锁

这个时候就考虑用redis的hash结构，因为你不仅只有key-value,还有个state属性，即加锁次数

#### redis的hash数据结构 ####

##### 1) hset #####

> hset key field value

![在这里插入图片描述][da18a86b7558434ca599cd0edb51a85c.png]  
![在这里插入图片描述][a9bf1db0a10a4871bff986d28043038b.png]  
hash可以简单看成一个大Map中套着个小Map <key , <key1,value> >

##### 2) hexists #####

> 作用：测试给定key下的field是否存在。  
> 格式：hexists key field

![在这里插入图片描述][e49ff5561e6f4b688cf0dc2d3c2757f4.png]

##### 3) hincrby #####

> 作用：增减数值  
> 格式：hincrby key field increment

![在这里插入图片描述][ed8407e339d84064abbd700165f79609.png]

把age+1 变成了12

#### 加锁优化为可重入 ####

*  1.  判断锁是否存在(exists),若不存在则直接获取锁 hset key field value
 *  1.  若锁存在则判断是否是自己的锁(hexists)，若是则重入：hincrby key field increment
 *  1.  否则重试，递归/循环

##### 1)写成LUA脚本 #####

if redis.call('exists','lock')==0 
     then redis.call('hset','lock',uuid,1) 
    	  redis.call('expire','lock',30)
     	  return 1
     elseif redis.call('hexists','lock',uuid)==0
     then redis.call('hincrby','lock',uuid,1) 
     	  redis.call('expire','lock',30)
     	  return 1
     else return 0
     end

这里可以再优化下  
![在这里插入图片描述][81c1c588ea774ccd9facbe39c1b0240d.png]

hincrby若没有key field会自动生成，此处可替换hset

if redis.call('exists','lock')==0  or redis.call('hexists','lock',uuid)==0
     then redis.call('hincrby','lock',uuid,1) 
     	  redis.call('expire','lock',30)
     	  return 1
     else return 0
     end

再将KEYS,ARGV加入后拼凑成一句语句

if redis.call('exists',KEYS[1])==0  or redis.call('hexists',KEYS[1],ARGV[1])==1 then redis.call('hincrby',KEYS[1],ARGV[1],1) redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end

##### 2) 测试 #####

1.  先简单加锁 参数 1 “lock” “1234567” 30  
    ![在这里插入图片描述][c92f971fea4b46d4b252bddeb12bcb48.png]

![在这里插入图片描述][29c84dd3370c49b388b2a7de958f9857.png]  
加锁成功

1.  重入加锁 参数 1 “lock” “1234567” 30  
    ![在这里插入图片描述][9b6c78b9ca4e43a898169e7fedd384fd.png]

![在这里插入图片描述][a54d64c7e20341739852f874a8451ee5.png]

*  value变成了2， 而且失效时间成功更新了

1.  先参数 1 “lock” “123” 30 再执行参数 1 “lock” “1234567” 30

![在这里插入图片描述][12aeaec2dc804dee84c5d20eec427022.png]  
![在这里插入图片描述][6e6077fd312042a398aeb7c011b03ea7.png]  
后一条加锁失败，直至行了123那条。测试成功。

#### 解锁优化为可重入 ####

##### 1) 编写LUA脚本 #####

*  判断自己的锁是否存在(hexists),不存在则返回nil
 *  若自己的锁存在，则减1(hincrby -1)，判断减1后的值是否为0，为0则释放锁(del)并返回1
 *  不为0，返回0

LUA脚本

if redis.call('hexists','lock',uuid) == 0
     then return nil
     elseif redis.call('hincrby', 'lock',uuid,-1)==0 
     then return redis.call('del','lock')
     else return 0
     end

把参数和key填充进去后，优化成一句语句

if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then return nil elseif redis.call('hincrby', KEYS[1],ARGV[1],-1)==0 then return redis.call('del',KEYS[1]) else return 0 end

##### 2）测试 #####

*  先参数 1 “lock” “1234567”  
    ![在这里插入图片描述][9b37fc8ef4124852af84bcfe1efa3c75.png]  
    当前没有该锁，返回nil
 *  用之前脚本加锁  
    ![在这里插入图片描述][5bc809c2210e4cad944e355faa6cd06d.png]  
    加锁一次，解锁一次，返回1，解锁第二次，返回nil
 *  多次加锁，多次解锁  
    ![在这里插入图片描述][873be40026b34fa499fe5628985e37e0.png]  
    两次加锁成功，返回1，解锁第一次返回0，第二次返回1。

#### 代码改造 ####

##### 1） 代码较复杂，将lock类单独拿出来定义使用 #####

DistributedRedisLock 参照ReentrantLock实现Lock接口

public class DistributedRedisLock implements Lock {
        
        @Override
        public void lock() {
        
            
        }
    
        @Override
        public void lockInterruptibly() throws InterruptedException {
        
    
        }
    
        @Override
        public boolean tryLock() {
        
            return false;
        }
    
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        
            return false;
        }
    
        @Override
        public void unlock() {
        
    
        }
    
        @Override
        public Condition newCondition() {
        
            return null;
        }
    }

##### 2） 工厂模式 DistributedLockClent #####

由于后续可能还有其他分布式锁类，直接用工厂模式实现。  
将StringRedisTemplate传递，因为只有DistributedLockClent添加了@Component供其他类注入

@Component
    public class DistributedLockClient {
        
    
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        public DistributedRedisLock getRedisLock(String key){
        
            return new DistributedRedisLock(redisTemplate,key);
        }
    
    }

##### 3）DistributedRedisLock #####

\-加锁

@Override
        public void lock() {
        
            tryLock();
        }
     	@Override
        public boolean tryLock() {
        
            try {
        
                return tryLock(-1,TimeUnit.SECONDS);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
        }
    	
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        
            return false;
        }

层层调用后修改tryLock即可。

/**
         * 加锁方法
         * @param time the maximum time to wait for the lock
         * @param unit the time unit of the {@code time} argument
         * @return
         * @throws InterruptedException
         */
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        
            // 如果不是默认调用的，那么自动计算出秒数
            if(time != -1){
        
                expire = unit.toSeconds(time);
            }
    
            // 如果没有锁加锁，如果是我的锁，重入 state+1
            String script = "if redis.call('exists',KEYS[1])==0  or redis.call('hexists',KEYS[1],ARGV[1])==1 " +
                    "then" +
                    "   redis.call('hincrby',KEYS[1],ARGV[1],1) " +
                    "   redis.call('expire',KEYS[1],ARGV[2]) " +
                    "   return 1 " +
                    "else " +
                    "   return 0 " +
                    "end";
    
            // 如果return 0 即抢锁失败，则循环抢
            while (Boolean.FALSE.equals(redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(key), uuid, String.valueOf(expire)))){
        
                Thread.sleep(50);
            }
            return true;
        }

*  解锁

/**
         * 解锁方法
         */
        @Override
        public void unlock() {
        
            // 如果不是我的锁，return nil 是我的锁减1，建减后state为0，则全部解锁完成return 1 ，不为0， 则return 0
            String script = " if redis.call('hexists',KEYS[1],ARGV[1]) == 0 " +
                    "then " +
                    "   return nil " +
                    "elseif redis.call('hincrby', KEYS[1],ARGV[1],-1)==0 " +
                    "then " +
                    "   return redis.call('del',KEYS[1]) " +
                    "else return 0 " +
                    "end";
            Long flag = redisTemplate.execute(new DefaultRedisScript<>(script,Long.class),Arrays.asList(key),uuid);
            if(flag == null){
        
                throw new IllegalMonitorStateException("this lock does not belong to you");
            }
        }

由于返回值有nil , 1, 0 所有返回类型为 Long.class，分别对应null,1,0

##### 4) StockService #####

@Service
    public class StockService {
        
    
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        @Autowired
        private DistributedLockClient distributedLockClient;
    
        public void deduct() {
        
            DistributedRedisLock redisLock = distributedLockClient.getRedisLock("lock");
            redisLock.lock();
    
            try{
        
                // 1。 查询库存
                String stockStr = redisTemplate.opsForValue().get("stock");
                if (!StringUtil.isNullOrEmpty(stockStr)) {
        
                    int stock = Integer.parseInt(stockStr);
                    // 2。 判断条件是否满足
                    if (stock > 0) {
        
                        // 3 更新redis
                        redisTemplate.opsForValue().set("stock", String.valueOf(stock - 1));
                    }
                }
            }finally {
        
               redisLock.unlock();
            }
        }
    }

#### 测试 ####

![在这里插入图片描述][5edfda21268c4a188a29aba3528b945a.png]  
并发达到了440  
![在这里插入图片描述][ba467b78d6104b6cab886315b8bda20d.png]  
库存也正常清空

#### uuid优化 ####

目前是每个线程都生成一个uuid,在可重入可能会出现问题，

public void test1(){
        
            DistributedRedisLock redisLock = distributedLockClient.getRedisLock("lock");
            redisLock.lock();
            test2();
            redisLock.unlock();
            
        }
        public void test2(){
        
            DistributedRedisLock redisLock = distributedLockClient.getRedisLock("lock");
            redisLock.lock();
            redisLock.unlock();
        }

优化为线程id+uuid，且一个工厂类生成一个uuid的方式

##### 1) DistributedLockClient #####

@Component
    public class DistributedLockClient {
        
    
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        public DistributedLockClient() {
        
            this.uuid = UUID.randomUUID().toString();
        }
    
        private String uuid;
    
        public DistributedRedisLock getRedisLock(String key){
        
            return new DistributedRedisLock(redisTemplate,key,uuid);
        }
    
    }

##### 2) DistributedRedisLock #####

public String getId(){
        
            return uuid + ":" + Thread.currentThread().getId();
        }

把之前的uuid使用地方，替换成getId()即可。

测试后成功。

### 6. 自动续期 ###

定时任务（时间驱动 Timer定时器） + LUA脚本

#### 1） Timer定时器 ####

public static void main(String[] args) {
        
            System.out.println("定时任务开始时间" + System.currentTimeMillis());
    
            new Timer().schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println("定时任务执行时间" + System.currentTimeMillis());
                }
            },2000,5000);
        }

![在这里插入图片描述][8bc0a6f7db5e4b00a68945fba812cb24.png]  
由于它可以手动取消，所以选择了它来使用

#### 2) LUA脚本 ####

*  判断自己的锁是否存在(hexists)，若存在则重置过期时间

if redis.call('hexists','lock',uuid) == 1 
    then return redis.call('expire','lock',30)
    else return 0
    end

整理后

if redis.call('hexists',KEYS[1],ARGV[1]) == 1 then return redis.call('expire',KEYS[1],ARGV[2]) else return 0 end

#### 3) DistributedRedisLock ####

private void renewExpire(){
        
            // 如果锁存在则续期，不存在则不续期
            String script = "if redis.call('hexists',KEYS[1],ARGV[1]) == 1 " +
                    "then " +
                    "   return redis.call('expire',KEYS[1],ARGV[2]) " +
                    "else " +
                    "   return 0 end";
    
            new Timer().schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    // 如果锁还在，则自动续期
                    if(Boolean.TRUE.equals(redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(key), uuid, String.valueOf(expire)))){
        
                        renewExpire();
                    }
    
                }
            },expire*1000/3);
        }

同时，修改初始化的uuid,防止定时器内部的线程id不同。

public DistributedRedisLock(StringRedisTemplate redisTemplate, String key, String uuid) {
        
            this.redisTemplate = redisTemplate;
            this.key = key;
            this.uuid = uuid + ":" + Thread.currentThread().getId();
        }

#### 4) 测试 ####

![在这里插入图片描述][e3066395cda348abb63a7e40fd8ff659.png]  
成功，但并发较低100，很耗线程。

## 总结 ##

### 加锁 ###

1.  setnx: 独占排他 死锁、不可重入、原子性
2.  set k v ex 30 nx: 独占排他 死锁 不可重入
3.  hash + lua脚本: 可重入锁

*  判断锁是否占用，若没有占用则直接获取锁，并设置过期时间
 *  若锁被占用，则判断是否当前线程占用，如果是则重入并重置过期时间
 *  否则获取锁失败，在代码中重试

1.  Timer定时器+lua脚本：实现锁的自动续期

*  判断是否是自己的锁，若是则续期。

### 解锁 ###

1.  del: 导致误删
2.  先判断再删除，同时保持原子性: lua脚本
3.  hash+lua脚本：可重入

*  判断当前线程的锁是否存在，不存在则返回nil，抛出异常
 *  存在则直接减1，判断减1后的值是否为0，为0则释放锁(del),并返回1
 *  不为0，则返回0

### 重试 循环/迭代 ###

[4d708961014a4aaf839edca0c8b1b56f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b3a79475aaba44eaa44c768d717f1b71.png
[918aa5c78f5e4e0283d822a6ac4c7bc5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c2a05fb1db27479eaec4b92b807197ac.png
[5e940096235a4c3a918dcce35e3bc1b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6c956f65946d4e2c9a7ecf8247285642.png
[60d899d6a5694ffe96826ea403711e25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e8ef36a8e3d3472d9a17654a1cb1d2c1.png
[9391ff3ffd3a4af9b9fa5fb810ba9903.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/440287c668bc4d0cbfaaf4acf786b866.png
[04098ba1d3444d3db7547f73beabaebc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/31cf306afe0b45b99da78d611af78cde.png
[c587f688af9a40379e1059220b96fc6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/baaebee319274c7f8863501fb3bdce63.png
[7b3e141778de46b098a6a7f1f0590212.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b26a66f5714348d483b5e277f9b232ac.png
[51c632370117410e8ce29594aab13f38.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/322f88be4b99431a9c3b24f83ec18b41.png
[00ab6788b51e428f907d63ca6433e6a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c4c9b4c8edb842368d1761ab19ce6e75.png
[72d21c7f9fb645058c68e402eb361ca6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/72691a2e14004940b2cf37776d759810.png
[05353cfceb5942a0bf36a8e175e2f4b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5aa976a5397f412b9a40f47904b7c9e0.png
[ReentrantLock]: https://blog.csdn.net/ideaxx/article/details/128504467?spm=1001.2014.3001.5501
[da18a86b7558434ca599cd0edb51a85c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c2a52ffef0af46799af0f01b9a988181.png
[a9bf1db0a10a4871bff986d28043038b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/56a5bbba4399426687c33ed6ab28b016.png
[e49ff5561e6f4b688cf0dc2d3c2757f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f51af15f491b498da73899a723a4540e.png
[ed8407e339d84064abbd700165f79609.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d099f579da9947ab9d7a9e03cbb62f16.png
[81c1c588ea774ccd9facbe39c1b0240d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/af7657ae2a3046eca175de5995342c77.png
[c92f971fea4b46d4b252bddeb12bcb48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/764d0622a0654c19bef21ab1ea4971df.png
[29c84dd3370c49b388b2a7de958f9857.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/155e1440cd0f49049d46359eb5eead11.png
[9b6c78b9ca4e43a898169e7fedd384fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/deefe8f09f994745b1942aacd77d0411.png
[a54d64c7e20341739852f874a8451ee5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/33141df03bf245fcb5c4beb5191ebced.png
[12aeaec2dc804dee84c5d20eec427022.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/75f3fba395cb4aeaaf2398d4bb9d7e25.png
[6e6077fd312042a398aeb7c011b03ea7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e2d45ce30b814df6b971cf4eb0334483.png
[9b37fc8ef4124852af84bcfe1efa3c75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/58e0534bf7fa419f9a9d2b291d72bc85.png
[5bc809c2210e4cad944e355faa6cd06d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/cb249d18347c4359b3a569a332262307.png
[873be40026b34fa499fe5628985e37e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5dd54652180444e990975a5e1dd594ae.png
[5edfda21268c4a188a29aba3528b945a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4e2c29a898574d85a774a29bb83d944e.png
[ba467b78d6104b6cab886315b8bda20d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/546994a033a54a4185d169181cdcadf6.png
[8bc0a6f7db5e4b00a68945fba812cb24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/23ef038903ea4c9bbfad2929ff301d58.png
[e3066395cda348abb63a7e40fd8ff659.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a273a5f626d84febba7c3075cfce9d77.png