#开启事务
127.0.0.1:6379> MULTI
OK
#需要事务的命令，压入事务队列
127.0.0.1:6379> ......
#实际执行事务
127.0.0.1:6379> EXEC

#开启事务
127.0.0.1:6379> MULTI
OK
#发送事务中的第一个操作，但是Redis不支持该命令，返回报错信息
127.0.0.1:6379> PUT a:stock 5
(error) ERR unknown command `PUT`, with args beginning with: `a:stock`, `5`, 
#发送事务中的第二个操作，这个操作是正确的命令，Redis把该命令入队
127.0.0.1:6379> DECR b:stock
QUEUED
#实际执行事务，但是之前命令有错误，所以Redis拒绝执行
127.0.0.1:6379> EXEC
(error) EXECABORT Transaction discarded because of previous errors.

#开启事务
127.0.0.1:6379> MULTI
OK
#发送事务中的第一个操作，LPOP命令操作的数据类型不匹配，此时并不报错
127.0.0.1:6379> LPOP a:stock
QUEUED
#发送事务中的第二个操作
127.0.0.1:6379> DECR b:stock
QUEUED
#实际执行事务，事务第一个操作执行报错
127.0.0.1:6379> EXEC
1) (error) WRONGTYPE Operation against a key holding the wrong kind of value
2) (integer) 8

import lombok.extern.slf4j.Slf4j;
import org.hibernate.validator.constraints.NotBlank;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;

import static org.springframework.beans.factory.config.ConfigurableBeanFactory.SCOPE_PROTOTYPE;

/**
 * 基于单Redis节点实现的分布式锁
 * 注意，这里作用域为prototype，即原型模式，非单例。
 *
 * @author masaiqi
 * @date 2021/1/22 9:49 上午
 */
@Component
@Scope(SCOPE_PROTOTYPE)
@Slf4j
public class DistributedLockSingleRedis extends AbstractDistributedLock implements DistributedLock {

	/**
	 * 过期时间(second)
	 */
	private Integer expireTime;

	/**
	 * 删除文件的lua脚本对应的sha值
	 */
	@Value("${lua-sha.redis-lock}")
	private String delKeySha;

	/**
	 * 默认过期时间(second) 半小时
	 */
	private Integer defaultExpireTime = 30 * 60;

	/**
	 * 初始化状态
	 * 多次调用只生效一次
	 *
	 * @param expireTime 过期时间
	 * @return void
	 * @author sq.ma
	 * @date 2021/1/22 12:01 下午
	 */
	public void initState(@NotBlank String lockKey, @NotBlank String clientId, Integer expireTime) {
		if (StringUtils.hasText(lockKey) && this.lockKey == null) {
			this.lockKey = lockKey;
		}
		if (StringUtils.hasText(clientId) && this.clientId == null) {
			this.clientId = clientId;
		}
		if (this.expireTime == null) {
			//添加随机时间(0 ～ 2 分钟)，避免大量缓存同时失效导致缓存雪崩
			int randomNum = (int) (Math.random() * 60 * 2);
			if (expireTime != null) {
				this.expireTime = expireTime + randomNum;
			} else {
				//认为必传 否则可能造成锁永远无法释放(客户端宕机) 所以这里设置默认值。
				this.expireTime = this.defaultExpireTime + randomNum;
			}
		}
	}

	/**
	 * 阻塞式获取锁，一直堵塞直到成功拿到锁
	 */
	@Override
	public void lock() {
		Jedis jedis = null;
		try {
			jedis = RedisUtil.getJedisResource();
			while (setKey(jedis) == null) {
				// Do nothing. 结果为空 -> 没有获取到锁 -> 一直循环到获取到锁为止
			}
			log.info(String.format("[Key: %s | Value: %s] gets DistributedLockSingleRedis Lock", lockKey, clientId));
		} finally {
			RedisUtil.closeJedisWithLogging("DistributedLockSingleRedis Lock", jedis);
		}
	}

	/**
	 * 阻塞式获取锁，响应线程中断信号，如果发生中断立刻停止获取锁并检查并释放锁
	 *
	 * @throws InterruptedException
	 */
	@Override
	public void lockInterruptibly() throws InterruptedException {
		if (Thread.interrupted()) {
			throw new InterruptedException();
		}
		Jedis jedis = null;
		try {
			jedis = RedisUtil.getJedisResource();
			while (setKey(jedis) == null) {
				if (Thread.interrupted()) {
					throw new InterruptedException();
				}
			}
			log.info(String.format("[Key: %s | Value: %s] gets DistributedLockSingleRedis Lock", lockKey, clientId));
		} finally {
			RedisUtil.closeJedisWithLogging("DistributedLockSingleRedis Lock", jedis);
			unlock();
		}
	}

	/**
	 * 非阻塞式获取锁
	 */
	@Override
	public boolean tryLock() {
		Jedis jedis = null;
		Boolean result = false;
		try {
			jedis = RedisUtil.getJedisResource();
			if (setKey(jedis) != null) {
				log.info(String.format("[Key: %s | Value: %s] gets DistributedLockSingleRedis Lock", lockKey, clientId));
				result = true;
			}
		} finally {
			RedisUtil.closeJedisWithLogging("DistributedLockSingleRedis Lock", jedis);
		}
		return result;
	}

	/**
	 * 阻塞式获取锁,直到超时或者获取到锁后返回
	 */
	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		long tryTime = unit.toMillis(time);
		long hasTriedTime = 0;

		Jedis jedis = null;
		Boolean result = false;
		try {
			jedis = RedisUtil.getJedisResource();
			while (hasTriedTime <= tryTime) {
				long startTime = System.currentTimeMillis();
				String setKeyResult = setKey(jedis);
				if (setKeyResult != null) {
					log.info(String.format("[Key: %s | Value: %s] gets DistributedLockSingleRedis Lock", lockKey, clientId));
					result = true;
				}
				long endTime = System.currentTimeMillis();
				hasTriedTime = endTime - startTime + hasTriedTime;
			}
		} finally {
			RedisUtil.closeJedisWithLogging("DistributedLockSingleRedis Lock", jedis);
		}
		return result;
	}

	/**
	 * 释放锁
	 */
	@Override
	public void unlock() {
		Jedis jedis = null;
		try {
			jedis = RedisUtil.getJedisResource();
			// 执行lua脚本，对应resources/redis-lua/redis_lock_lua.script这个文件
			Long result = (Long) jedis.evalsha(delKeySha, 1, lockKey, clientId);
			if (result == 1L) {
				log.info(String.format("[Key: %s | Value: %s] releases DistributedLockSingleRedis Lock", lockKey, clientId));
			}
		} finally {
			RedisUtil.closeJedisWithLogging("DistributedLockSingleRedis Lock", jedis);
		}
	}

	@Override
	public Condition newCondition() {
		throw new RuntimeException("暂不支持!");
	}

	/**
	 * 状态检查，请调用{@link #initState(String, String, Integer)} 进行初始化。
	 */
	@Override
	public void checkState() {
		super.checkState();
		Assert.notNull(expireTime, "您必须传入过期时间!");
		Assert.hasText(delKeySha, "您必须传入sha!");
	}

	/**
	 * 设置redis值
	 *
	 * @return
	 */
	private String setKey(Jedis jedis) {
		checkState();
		// Set key if not exists -> execute command 'SET key value [EX seconds | PX milliseconds]  [NX]'
		return jedis.set(lockKey, clientId, SetParams.setParams().ex(expireTime).nx());
	}

}

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