import redis.clients.jedis.Jedis;

public class RedisDistributedLock {

    // Redis客戶端
    private Jedis jedis;
    // 鎖的路徑
    private String lockKey;
    // 鎖的持有者
    private String lockHolder;
    // 鎖的過期時間（單位：毫秒）
    private int expireTime;
    // 循環(huán)獲取鎖的時間間隔（單位：毫秒）
    private int acquireInterval;
    // 獲取鎖的最大等待時間（單位：毫秒）
    private int acquireTimeout;

    /**
     * 構造函數
     * @param jedis Redis客戶端
     * @param lockKey 鎖的路徑
     * @param expireTime 鎖的過期時間（單位：毫秒）
     * @param acquireInterval 循環(huán)獲取鎖的時間間隔（單位：毫秒）
     * @param acquireTimeout 獲取鎖的最大等待時間（單位：毫秒）
     */
    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime, int acquireInterval, int acquireTimeout) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.expireTime = expireTime;
        this.acquireInterval = acquireInterval;
        this.acquireTimeout = acquireTimeout;
        this.lockHolder = null;
    }

    /**
     * 獲取鎖
     * @return 是否獲取成功
     */
    public boolean acquire() {
        // 獲取當前時間戳
        long now = System.currentTimeMillis();
        // 計算獲取鎖的最后截止時間
        long acquireDeadline = now + acquireTimeout;
        // 循環(huán)嘗試獲取鎖
        while (System.currentTimeMillis() < acquireDeadline) {
            // 生成隨機的鎖持有者ID
            String holder = Long.toString(now) + "|" + Thread.currentThread().getId();
            // 將鎖持有者ID設置到鎖的值中，如果設置成功則表示獲取鎖成功
            if (jedis.set(lockKey, holder, "NX", "PX", expireTime) != null) {
                this.lockHolder = holder;
                return true;
            }
            // 如果獲取鎖失敗，則等待一段時間后再次嘗試獲取
            try {
                Thread.sleep(acquireInterval);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    /**
     * 釋放鎖
     * @return 是否釋放成功
     */
    public boolean release() {
        // 判斷當前鎖是否是該線程持有的，如果不是則不能釋放
        if (this.lockHolder != null && this.lockHolder.equals(jedis.get(lockKey))) {
            jedis.del(lockKey);
            return true;
        }
        return false;
    }
}

public class RedisDistributedLock {

   private static final long DEFAULT_EXPIRY_TIME = 30000;
   private static final int DEFAULT_RETRIES = 3;
   private static final long DEFAULT_RETRY_TIME = 500;

   private final JedisPool jedisPool;

   public RedisDistributedLock(JedisPool jedisPool) {
       this.jedisPool = jedisPool;
   }

   /**
    * 獲取分布式鎖
    * @param lockKey 鎖key
    * @param clientId 客戶端標識
    * @return 是否獲取到鎖
    */
   public boolean acquire(String lockKey, String clientId) {
       return acquire(lockKey, clientId, DEFAULT_EXPIRY_TIME, DEFAULT_RETRIES, DEFAULT_RETRY_TIME);
   }

   /**
    * 獲取分布式鎖
    * @param lockKey 鎖key
    * @param clientId 客戶端標識
    * @param expiryTime 鎖超時時間，單位毫秒
    * @param retryTimes 嘗試獲取鎖的次數
    * @param retryInterval 每次嘗試獲取鎖的間隔時間，單位毫秒
    * @return 是否獲取到鎖
    */
   public boolean acquire(String lockKey, String clientId, long expiryTime, int retryTimes, long retryInterval) {
       try (Jedis jedis = jedisPool.getResource()) {
           int count = 0;
           while (count++ < retryTimes) {
               // 生成隨機字符串作為value，保證每個客戶端的鎖值是唯一的
               String lockValue = UUID.randomUUID().toString();
               // 嘗試獲取鎖，成功返回1，失敗返回0
               String result = jedis.set(lockKey, lockValue, "NX", "PX", expiryTime);
               if ("OK".equals(result)) {
                   // 將鎖標識與客戶端匹配，便于解鎖時判斷鎖是否屬于當前客戶端
                   jedis.hset("lockClientIdMap", lockKey, clientId);
                   return true;
               }
               try {
                   Thread.sleep(retryInterval);
               } catch (InterruptedException e) {
                   Thread.currentThread().interrupt();
                   return false;
               }
           }
       }
       return false;
   }

   /**
    * 釋放分布式鎖
    * @param lockKey 鎖key
    * @param clientId 客戶端標識
    * @return 是否成功釋放鎖
    */
   public boolean release(String lockKey, String clientId) {
       try (Jedis jedis = jedisPool.getResource()) {
           // 獲取鎖標識對應的客戶端標識，判斷鎖是否屬于當前客戶端
           String storedClientId = jedis.hget("lockClientIdMap", lockKey);
           if (clientId.equals(storedClientId)) {
               // 刪除鎖key
               jedis.del(lockKey);
               // 刪除鎖標識對應的客戶端標識
               jedis.hdel("lockClientIdMap", lockKey);
               return true;
           }
       }
       return false;
   }

}