redis 分布式锁

 package cn.admin.srv.util;

    
  
    
 import lombok.extern.slf4j.Slf4j;
    
 import org.springframework.beans.factory.annotation.Autowired;
    
 import org.springframework.data.redis.core.RedisCallback;
    
 import org.springframework.data.redis.core.RedisTemplate;
    
 import org.springframework.stereotype.Component;
    
  
    
 import java.util.Objects;
    
  
    
 @Component
    
 @Slf4j
    
 public class CommonRedisHelper {
    
     public static final String LOCK_PREFIX = "redis_lock";
    
     public static final int LOCK_EXPIRE = 10 * 1000; // 锁过期时间ms
    
  
    
     public static final int LOCK_EXPIRE_WAIT = 100; // 获取锁失败后的等待时间ms，等待时间过去后再次尝试获取
    
  
    
     private static final int LOCK_TIMEOUT = 5 * 1000; //锁等待时间，ms
    
  
    
     @Autowired
    
     RedisTemplate redisTemplate;
    
  
    
  
    
     public boolean lock(String key){
    
     log.info("lock invoke, key = {}", key);
    
     return (Boolean) redisTemplate.execute((RedisCallback) connection -> {
    
         //获取锁的超时时间，超过这个时间还没获取到锁，认为失败
    
         int timeoutMs = LOCK_TIMEOUT;
    
         while (timeoutMs >= 0) {
    
             //锁过期时间
    
             long expireAt = System.currentTimeMillis() + LOCK_EXPIRE + 1;
    
             Boolean acquire = connection.setNX(key.getBytes(), String.valueOf(expireAt).getBytes());
    
  
    
             //锁获取成功，直接返回
    
             if (acquire) {
    
                 log.info("lock acquire success, key = {}", key);
    
                 return true;
    
             }
    
  
    
             byte[] value = connection.get(key.getBytes());
    
             boolean isExpired = Objects.nonNull(value) && Long.parseLong(new String(value)) < System.currentTimeMillis();
    
             
    
             //如果当前锁过期 尝试通过更新锁时间 来获取锁
    
             if (isExpired) {
    
                 byte[] oldValue = connection.getSet(key.getBytes(), String.valueOf(System.currentTimeMillis() + LOCK_EXPIRE + 1).getBytes());
    
                 //如果锁的过期时间值 没有被其他线程修改 则获取锁成功
    
                 if (Objects.nonNull(oldValue) && Objects.equals(Long.parseLong(new String(value)), Long.parseLong(new String(oldValue)))) {
    
                     log.info("lock acquire success2 , key {}", key);
    
                     return true;
    
                 }
    
                 }
    
             //没有获取锁  等待时间 再去获取锁
    
             timeoutMs -= LOCK_EXPIRE_WAIT;
    
             try {
    
                 Thread.sleep(LOCK_EXPIRE_WAIT);
    
             } catch (InterruptedException e) {
    
                 log.error("lock error , key {}",key , e);
    
             }
    
         }
    
         //超时未获取到锁 则获取失败
    
         return false;
    
             });
    
     }
    
  
    
     /** * 删除锁
    
      * * @param key
    
      */
    
     public void deleteLock(String key) {
    
     redisTemplate.delete(key);
    
     log.info("删除lock key {}", key);
    
     }
    
 }