@Component

public class RedisLockManager implements Lock {

    Logger logger = LoggerFactory.getLogger(RedisLockManager.class);

    @Autowired

    RedisTool redisManager;

    /**

     * 请求锁的超时时间(ms)

     */

    private final long TIME_OUT = 30000;

    /**

     * 锁的有效时间(毫秒)

     */

    private long expire = 15000;

    private String key;

    private String value;

    private volatile boolean isLocked = false;

    public void setKey(String key) {

        this.key = key;

    }

    public void setValue(String value) {

        this.value = value;

    }

    @Override

    public void lock() {

        //系统当前时间，毫秒

        long nowTime = System.nanoTime();

        //请求锁超时时间，毫秒

        long timeout = TIME_OUT * 1000000;

        ThreadLocalRandom random = ThreadLocalRandom.current();

        try {

            while ((System.nanoTime() - nowTime) < timeout) {

                boolean flag = redisManager.tryGetDistributedLock(this.key, this.value, this.expire);

                if (flag) {

                    isLocked = true;

                    //上锁成功结束请求

                    break;

                }

                Thread.sleep(3, random.nextInt(500));

            }

        } catch (Exception e) {

            isLocked = false;

            logger.error(e.getMessage(), e);

        }

    }

    @Override

    public void unlock() {

        //释放锁

        //不管请求锁是否成功，只要已经上锁，客户端都会进行释放锁的操作

        if (isLocked) {

            redisManager.releaseDistributedLock(this.key, this.value);

            this.isLocked = false;

        }

    }

    @Override

    public void lockInterruptibly() {

        // TODO Auto-generated method stub

    }

    @Override

    public boolean tryLock() {

        // TODO Auto-generated method stub

        return false;

    }

    @Override

    public boolean tryLock(long time, TimeUnit unit) {

        this.expire = unit.toMillis(time);

        this.lock();

        return this.isLocked;

    }

    @Override

    public Condition newCondition() {

        // TODO Auto-generated method stub

        return null;

    }

}

@Component

public class RedisTool {

　　@Autwire
　　Jedis jedis;

    private final String LOCK_SUCCESS = "OK";

    private final String SET_IF_NOT_EXIST = "NX";

    private final String SET_WITH_EXPIRE_TIME = "PX";

    /**

     * 尝试获取分布式锁

     * @param jedis Redis客户端

     * @param lockKey 锁

     * @param requestId 请求标识

     * @param expireTime 超期时间

     * @return 是否获取成功

     */

    public boolean tryGetDistributedLock(String lockKey, String requestId, int expireTime) {

        String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

        if (LOCK_SUCCESS.equals(result)) {

            return true;

        }

        return false;

    }

   private final Long RELEASE_SUCCESS = 1L;

    /**

     * 释放分布式锁

     * @param jedis Redis客户端

     * @param lockKey 锁

     * @param requestId 请求标识

     * @return 是否释放成功

     */

    public boolean releaseDistributedLock(String lockKey, String requestId) {

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));

        if (RELEASE_SUCCESS.equals(result)) {

            return true;

        }

        return false;

    }

}