1. private final static int INIT_VERSION = 2;
    2.     /**
    3.      * 单位为毫秒; 获取的锁的自动释放时间是100ms.
    4.      */
    5.     private final static int DEFAULT_EXPIRE_TIME = 100;
    6.     /**
    7.      * 单位为毫秒; 获取锁时, 默认的等待时间. 重试次数计算: DEFAULT_TIMEOUT/DEFAULT_LOCK_RETRY_INTERVAL
    8.      */
    9.     private final static int DEFAULT_TIMEOUT = 200;
    10.     /**
    11.      * 单位为毫秒; 获取锁时, 默认重试的时间间隔是50ms.
    12.      */
    13.     private final static int DEFAULT_LOCK_RETRY_INTERVAL = 50;
    14.     /**
    15.      * 释放锁时, 默认进行五次重试.
    16.      */
    17.     private final static int DEFAULT_UNLOCK_RETRY_COUNT = 5;
    19.     private ThreadLocal<String> threadValue = new ThreadLocal<String>();
    21.     @Override
    22.     public boolean lock(String key) {
    23.         return lock(key, DEFAULT_EXPIRE_TIME, DEFAULT_TIMEOUT);
    24.     }
    26.     @Override
    27.     public boolean lock(String key, int expireTime, long timeout) {
    28.         long start = System.currentTimeMillis();
    29.         for (; ; ) {
    30.             boolean rs = tryLock(key, expireTime);
    31.             if (rs) {
    32.                 return true;
    33.             }
    34.             long current = System.currentTimeMillis();
    35.             if ((current - start + DEFAULT_LOCK_RETRY_INTERVAL) > timeout) {
    36.                 LOG.error("lock timeout. key:{}", key);
    37.                 return false;
    38.             }
    39.             waitToRetry();
    40.         }
    41.     }
    43.     @Override
    44.     public boolean tryLock(String key, int expireTime) {
    45.         try {
    46.             DataEntry<String> dataEntry = super.get(key);
    47.             // 如果已经有值, 则判断是否是重入场景
    48.             if (dataEntry != null && !StringUtils.isBlank(dataEntry.getValue())) {
    49.                 String value = dataEntry.getValue();
    50.                 return threadValue.get() != null && threadValue.get().equals(value);
    51.             }
    52.             // 如果没有值, 则设置值, 获取锁
    53.             String value = threadValue.get();
    54.             if (value == null) {
    55.                 value = generateValue();
    56.                 threadValue.set(value);
    57.             }
    58.             super.setWithVersion(key, value, INIT_VERSION, expireTime);
    59.             return true;
    60.         } catch (Exception e) {
    61.             LOG.error("tryLock error. key:{}", key, e);
    62.             return false;
    63.         }
    64.     }
    66.     @Override
    67.     public boolean unlock(String key) {
    68.         String value = threadValue.get();
    69.         for (int i = 0; i < DEFAULT_UNLOCK_RETRY_COUNT; i++) {
    70.             try {
    71.                 DataEntry<String> stringDataEntry = super.get(key);
    72.                 if (null != stringDataEntry && StringUtils.isNotBlank(
    73.                     stringDataEntry.getValue()) && StringUtils.isNotBlank(value) && StringUtils.equals(
    74.                     stringDataEntry.getValue(), value)) {
    75.                     super.remove(key);
    76.                     threadValue.remove();
    77.                     return true;
    78.                 } else {
    79.                     LOG.error("unlock error. key:{}", key);
    80.                     return false;
    81.                 }
    82.             } catch (Exception e) {
    83.                 LOG.error("unlock error. key:{}", key, e);
    84.             }
    85.         }
    86.         LOG.error("unlock fail after retry ${} times, tair service may be unavailable now", DEFAULT_UNLOCK_RETRY_COUNT);
    87.         return false;
    88.     }
    90.     private void waitToRetry() {
    91.         try {
    92.             Thread.sleep(DEFAULT_LOCK_RETRY_INTERVAL);
    93.         } catch (Exception e) {
    94.             LOG.warn("waitToRetry error", e);
    95.         }
    96.     }
    98.     private String generateValue() {
    99.         return Thread.currentThread().getName() + "_" + UUID.randomUUID().toString();
    100.     }