/**
 * 通过redis实现对于分布式的环境下的并发管理（通过redis锁实现并发处理）
 */
public class RedisDistributionLock {
    private long lockTimeout = 6 * 1000;
    private final String lockKey;

    public RedisDistributionLock(String key) {
        this.lockKey = key;
    }

    /**
     * 加锁 取到锁加锁，取不到锁就返回
     *
     * @return
     */
    public synchronized long lock() {
        while (true) {
            long currentTime = System.currentTimeMillis();
            Long lock_timeout = currentTime + lockTimeout;
            long result = RedisClientTemplate.setnx(lockKey, String.valueOf(lock_timeout));

            if (result == 1) {
                RedisClientTemplate.expire(lockKey, (int) (lockTimeout / 1000));
                return lockTimeout;
            }
            String expireTimeStr = RedisClientTemplate.get(lockKey);
            if (StringUtil.isNotBlank(expireTimeStr)) {
                long expireTime = Long.parseLong(expireTimeStr);
                if (expireTime <= currentTime) {
                    String old = RedisClientTemplate.getSet(lockKey, String.valueOf(lock_timeout));
                    if (StringUtil.isNotBlank(old)) {
                        if (expireTime == Long.parseLong(old)) {
                            RedisClientTemplate.expire(lockKey, (int) (lockTimeout / 1000));
                            return lock_timeout;
                        }
                    }
                }
            } else {
                continue;
            }
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 解锁
     */
    public synchronized void unlock() {
        RedisClientTemplate.del(lockKey);
    }
}