锁 - 分布式锁工具

锁概述

在计算机科学中，锁是在执行多线程时用于强行限制资源访问的同步机制，即用于在并发控制中保证对互斥要求的满足。

锁相关概念

• 锁开销：完成一个锁可能额外耗费的资源，比如一个周期所需要的时间，内存空间。
  
• 锁竞争：一个线程或进程，要获取另一个线程或进程所持有的锁，边会发生锁竞争。锁粒度越小，竞争的可能越小。
  
• 死锁：多个线程争夺资源互相等待资源释放导致阻塞；由于无限期阻塞，程序不能正常终止。
  

分类

• 乐观锁、悲观锁：是否锁定同步资源。
  
  
  
  • 乐观锁：认为其他线程对数据访问时 不会 修改数据，实际未加锁，更新数据时判断是否被其他线程更新了（读时不加锁，写时加锁）。
    
    
    
    • 适合多读的场景，因为读操作没有加锁。
      
    • 实现原理：CAS (compare-and-swap) ，无锁算法，原子操作比较更新。
      
    • 使用：
      
      
      
      • Java 中的 CAS 锁（AtomicXxx）通过 JNI 调用 CPU 中的 cmpxchg 汇编指令实现
        
      • 数据库表增加 version 字段，更新时判断 version 未改变。
        
      
      
    • 缺陷：
      
      
      
      • ABA 问题：数据发生类似变化（A -> B -> A），会认为数据没有改变。
        JDK 1.5 引入 AtomicStampedReference 增加标志位（1A -> 2B -> 3A）
        
      • 自旋问题：CAS 无法获取到锁会在超时时间内循环获取，造成 CPU 资源浪费
        
      
      
    
    
  • 悲观锁：认为其他线程对数据访问时 一定会 修改数据，访问数据时加锁同步处理（一开始加锁无论读写）。
    
    
    
    • 适合多写的场景，独占数据的读写权限，确保数据的读取和更新都是准确的。
      
    
    
  
  
• 读写锁
  
  
  
  • 读锁：共享锁，可支持多线程并发读。
    
  • 写锁：独享锁，读写、写写互斥。
    
  • 示例：ReentrantReadWriteLock
    
  
  
• 可重入锁、不可重入锁
  
  
  
  • 可重入锁（递归锁）：一个线程在已加锁范围内代码中再次进行加锁能够获取到锁
    
    
    
    • synchronized 、 ReentrantLock
      
    
    
  • 不可重入锁：一个线程对在已加锁范围内代码中再次进行加锁操作，由于第二次加锁时需要等待上次锁释放才可以加锁造成锁的互相等待
    
  
  
• 公平锁、非公平锁
  
  
  
  • 公平锁：多个线程按照申请锁的顺序来获取锁，依赖 AQS 队列，线程直接进入队列中排队，第一个线程才能获取到锁
    
  • 非公平锁：多个线程加锁时尝试直接获取锁，获取不到进入队列，可能出现后申请锁的线程先获取到锁
    
    
    
    • 优点：可以减少唤起线程的开销，整体吞吐效率高
      
    • 缺点：处于等待队列中的线程可能饿死
      
    • synchronized
      
    
    
  • 示例：ReentrantLock 默认为非公平锁，构造方法可指定为公平锁 new ReentrantLock(true);
    
  
  
• 偏向锁、轻量锁、重量锁：synchronized 的三种锁状态。
  
  
  
  • 偏向锁：锁标志位 101，在对象头（Mark Word）和栈帧中锁记录（Lock Record）里存储线程ID，通过 对比 Mark Word 避免执行 CAS
    
    
    
    • JDK 6 引入，JDK 15 标记废弃，可通过 JVM 参数（-XX:+UseBiasedLocking）手动启用
      
    
    
  • 轻量锁：锁标志位 000，偏向锁时出现竞争升级为轻量锁，未获取到锁的线程自旋获取，通过 CAS + 自旋 避免线程阻塞唤醒
    
  • 重量锁：锁标志位 010，轻量锁自旋超过一定此处升级为重量锁，未获取到锁的线程休眠
    
  
  
• 分段锁、自旋锁：锁设计，非特定的锁。
  
  
  
  • 分段锁：将要锁定的数据拆分成段后对所需数据段加锁，减少锁定范围
    
    
    
    • ConcurrentHashMap 在 JDK 8 之前使用 Segment （继承 ReentrantLock）对桶数组分割分段加锁
      
    
    
  • 自旋锁：试探获取资源，未获取到采取自旋循环 where(true) 再次试探获取，不阻塞线程
    
    
    
    • 轻量锁通过 CAS + 自旋 实现
      
    • 优点：减少上下文切换
      
    • 缺点：占用 CPU
      
    
    
  
  

相关阅读：

• Java中的锁 - 沈三白
  
• 听说你知道什么是锁 --JAVA - 罗小扇
  

自定义锁工具

1 ：Redis 分布式锁（简单实现）

使用 ThreadLocal 保存锁对应的唯一标识
加锁：使用 STRING 保存锁定标识， 'SET key value PX NX' 确保一个 key 只能加锁一次
解锁：Lua 脚本判断是自己加的锁进行释放

• 工具类
       RedisSimpleLockUtil.java
  1. // 使用 ThreadLocal 保存锁对应的唯一标识
  2. private static final ThreadLocal<String> LOCK_FLAG = ThreadLocal.withInitial(() ->
  3.         UUID.randomUUID().toString().replace("-", "").toLowerCase()
  4. );
  6. // 尝试加锁
  7. private boolean tryLock(String key, long ttl) {
  8.     try {
  9.         String val = LOCK_FLAG.get();
  10.         Boolean lockRes = redisTemplate.opsForValue()
  11.                 .setIfAbsent(key, val, ttl, TimeUnit.MILLISECONDS);
  12.         log.debug("tryLock, key={}, val={}, lockRes={}", key, val, lockRes);
  13.         return Boolean.TRUE.equals(lockRes);
  14.     } catch (Exception e) {
  15.         log.error("tryLock occurred an exception", e);
  16.     }
  18.     return false;
  19. }
  21. // 解锁
  22. public boolean unlock(String key) {
  23.     boolean succeed = false;
  24.     try {
  25.         List<String> keys = Collections.singletonList(key);
  26.         Object[] args = {LOCK_FLAG.get()};
  27.         Long unlockRes = redisTemplate.execute(UNLOCK_SCRIPT, keys, args);
  28.         log.debug("unlock, key={}, args={}, unlockRes={}", key, args, unlockRes);
  29.         succeed = Optional.ofNullable(unlockRes).filter(res -> res > 0).isPresent();
  30.     } catch (Exception e) {
  31.         log.error("unlock occurred an exception", e);
  32.     } finally {
  33.         if (succeed) {
  34.             LOCK_FLAG.remove();
  35.         }
  36.     }
  38.     return succeed;
  39. }

  复制代码
• Lua 脚本
    解锁： redis_unlock_simple.lua
  1. local lock_key = KEYS[1];
  2. local lock_flag = ARGV[1];
  4. --- 判断锁定的唯一标识与参数一致删除锁
  5. --- 返回值：1=解锁成功（删除成功），0=锁已失效或删除失败，-1=非自己的锁不支持解锁
  6. local val = redis.call('GET', lock_key);
  7. if (not val) then
  8.     return 0;
  9. elseif (val == lock_flag) then
  10.     return redis.call('DEL', lock_key);
  11. else
  12.     return -1;
  13. end

  复制代码
• 缺陷
  
  
  
  • 只能单次加锁（唯一标识通过 ThreadLocal 存储，解锁时会清理 ThreadLocal，多次加解锁会导致与预期不符）
    
  • 不可重入
    
  
  
• 参考：https://github.com/realpdai/tech-pdai-spring-demos/blob/main/264-springboot-demo-redis-jedis-distribute-lock/src/main/java/tech/pdai/springboot/redis/jedis/lock/lock/RedisDistributedLock.java
  

2 ：Redis 分布式锁

使用 ThreadLocal 保存 锁key 与 相应的唯一标识
加锁：使用 HASH 保存锁标识与加锁次数
解锁：Lua 脚本判断是自己加的锁进行释放
功能：可重入（Redis HASH）、支持对不同 key 进行加解锁（ThreadLocal）

<ul>工具类
     RedisLockUtil.java

1. // 使用 ThreadLocal 保存 锁key 与 唯一标识
2. private static final ThreadLocal<Map<String, String>> LOCK_FLAG =
3.         ThreadLocal.withInitial(HashMap::new);
4. // 尝试加锁
5. private long tryLock(String key, long ttl) {
6.     String uniqueFlag = LOCK_FLAG.get().get(key);
7.     if (uniqueFlag == null) {
8.         uniqueFlag = UUID.randomUUID().toString().replace("-", "");
9.         LOCK_FLAG.get().put(key, uniqueFlag);
10.     }
12.     try {
13.         List<String> keys = Collections.singletonList(key);
14.         Object[] args = {uniqueFlag, ttl};
15.         Long lockRes = redisTemplate.execute(LOCK_SCRIPT, keys, args);
16.         log.debug("tryLock, lock_flag={}, key={}, args={}, lockRes={}",
17.                 LOCK_FLAG.get(), key, args, lockRes);
18.         return lockRes != null ? lockRes : 0L;
19.     } catch (Exception e) {
20.         log.error("tryLock occurred an exception", e);
21.     }
23.     return 0L;
24. }
26. // 尝试解锁
27. public long tryUnlock(String key) {
28.     String uniqueFlag = LOCK_FLAG.get().get(key);
29.     if (uniqueFlag == null) {
30.         return 0L;
31.     }
33.     long lockNum = -1L;
34.     try {
35.         List<String> keys = Collections.singletonList(key);
36.         Object[] args = {uniqueFlag};
37.         Long unlockRes = redisTemplate.execute(UNLOCK_SCRIPT, keys, args);
38.         log.debug("unlock, key={}, args={}, unlockRes={}", key, args, unlockRes);
39.         lockNum = unlockRes != null ? unlockRes : 0L;
40.     } catch (Exception e) {
41.         log.error("release lock occurred an exception", e);
42.     } finally {
43.         if (lockNum == 0L) {
44.             LOCK_FLAG.get().remove(key);
45.             if (LOCK_FLAG.get().isEmpty()) {
46.                 LOCK_FLAG.remove();
47.             }
48.         }
49.     }
51.     return lockNum;
52. }

复制代码

Lua 脚本
        加锁： redis_lock.lua

1.   ```lua
2.   local lock_key = KEYS[1];
3.   local lock_flag = ARGV[1];
4.   --- 锁定时长，单位：毫秒
5.   local lock_ttl = tonumber(ARGV[2]);
7.   --- HASH 支持可重入
8.   --- lock_flag 保存加锁唯一标识
9.   --- lock_num 保存加锁次数
10.   local info = redis.call("HMGET", lock_key, "lock_flag", "lock_num");
11.   local h_flag = info[1];
12.   local h_num = tonumber(info[2]);
13.   if (h_num == nil or h_num < 0) then
14.       h_num = 0;
15.   end
17.   --- 返回加锁次数，未加锁成功返回 -1
18.   if (not h_flag or h_flag == lock_flag) then
19.       local res_num = h_num + 1;
20.       redis.call("HMSET", lock_key, "lock_flag", lock_flag, "lock_num", res_num);
21.       redis.call("PEXPIRE", lock_key, lock_ttl);
22.       return res_num;
23.   else
24.       return -1;
25.   end
26.   ```

复制代码

         解锁： redis_lock.lua [code]  ```lua  local lock_key = KEYS[1];  local lock_flag = ARGV[1];  --- HASH 支持可重入  --- lock_flag 保存加锁唯一标识  --- lock_num 保存加锁次数  local info = redis.call("HMGET", lock_key, "lock_flag", "lock_num");  local h_flag = info[1];  local h_num = tonumber(info[2]);  if (h_num == nil) then      h_num = 0;  end  --- 返回剩余加锁次数，未被加锁或解锁完返回 0，非自己加锁返回 -1  if (not h_flag) then      return 0;  elseif (h_flag == lock_flag) then      if (h_num