一.redis相关命令
setnx()命令:
setnx的含义就是SET if Not Exists,其主要有两个参数 setnx(key, value)。该方法是原子的,如果key不存在,则设置当前key成功,返回1;如果当前key已经存在,则设置当前key失败,返回0。
get()命令:
get(key) 获取key的值,如果存在,则返回;如果不存在,则返回nil;
getset()命令:
这个命令主要有两个参数 getset(key, newValue)。该方法是原子的,对key设置newValue这个值,并且返回key原来的旧值。
假设key原来是不存在的,那么多次执行这个命令,会出现下边的效果:
-
getset(key, “value1”) 返回nil,此时key的值会被设置为value1
-
getset(key, “value2”) 返回value1 此时key的值会被设置为value2
-
依次类推!
二.具体步骤
-
setnx(lockkey, 当前时间+过期超时时间) ,如果返回1,则获取锁成功;如果返回0则没有获取到锁,转向2。
2. get(lockkey)获取值oldExpireTime ,并将这个value值与当前的系统时间进行比较,如果小于当前系统时间,则认为这个锁已经超时,可以允许别的请求重新获取,转向3。 -
计算newExpireTime=当前时间+过期超时时间,然后getset(lockkey, newExpireTime) 会返回当前lockkey的值currentExpireTime。
-
判断currentExpireTime与oldExpireTime 是否相等,如果相等,说明当前getset设置成功,获取到了锁。如果不相等,说明这个锁又被别的请求获取走了,那么当前请求可以直接返回失败,或者继续重试。
-
在获取到锁之后,当前线程可以开始自己的业务处理,当处理完毕后,比较自己的处理时间和对于锁设置的超时时间,如果小于锁设置的超时时间,则直接执行delete释放锁;如果大于锁设置的超时时间,则不需要对锁进行处理。
分布式锁DistributedLockHandler类
package tk.mybatis.springboot.distributedLock;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
@Service("distributedLockHandler")
public class DistributedLockHandler {
private static final Integer Lock_Timeout = 3;
private Jedis jedis;
/**
* 外部调用加锁的方法
* @param lockKey 锁的名字
* @param timeout 超时时间(放置时间长度,如:5L)
* @return
*/
public boolean tryLock(String lockKey, Long timeout) {
try {
Long currentTime = System.currentTimeMillis();//开始加锁的时间
boolean result = false;
while (true) {
if ((System.currentTimeMillis() - currentTime) / 1000 > timeout) {//当前时间超过了设定的超时时间
System.out.println("Execute DistributedLockHandler.tryLock method, Time out.");
break;
} else {
result = innerTryLock(lockKey);
if (result) {
break;
} else {
System.out.println("Try to get the Lock,and wait 100 millisecond....");
Thread.sleep(100);
}
}
}
return result;
} catch (Exception e) {
System.out.println("Failed to run DistributedLockHandler.getLock method."+ e);
return false;
}
}
/**
* 释放锁
* @param lockKey 锁的名字
*/
public void realseLock(String lockKey) {
if(!checkIfLockTimeout(System.currentTimeMillis(), lockKey)){
jedis.del(lockKey);
}
}
/**
* 内部获取锁的实现方法
* @param lockKey 锁的名字
* @return
*/
private boolean innerTryLock(String lockKey) {
long currentTime = System.currentTimeMillis();//当前时间
String lockTimeDuration = String.valueOf(currentTime + Lock_Timeout + 1);//锁的持续时间
Long result = jedis.setnx(lockKey, lockTimeDuration);
if (result == 1) {
return true;
} else {
if (checkIfLockTimeout(currentTime, lockKey)) {
String preLockTimeDuration = jedis.getSet(lockKey, lockTimeDuration);
if (currentTime > Long.valueOf(preLockTimeDuration)) {
return true;
}
}
return false;
}
}
/**
* 判断加锁是否超时
* @param currentTime 当前时间
* @param lockKey 锁的名字
* @return
*/
private boolean checkIfLockTimeout(Long currentTime, String lockKey) {
if (currentTime > Long.valueOf(jedis.get(lockKey))) {//当前时间超过锁的持续时间
return true;
} else {
return false;
}
}
public DistributedLockHandler setJedis(Jedis jedis) {
this.jedis = jedis;
return this;
}
}
调用Demo:
package tk.mybatis.springboot.distributedLock;
import redis.clients.jedis.Jedis;
/**
* 基于redis的setnx()、get()、getset()方法 分布式锁
* @author KF01
*
*/
public class Demo {
private static final String lockKey = "Lock.TecentIm_Interface_Counter";
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1", 6379);
DistributedLockHandler distributedLockHandler = new DistributedLockHandler().setJedis(jedis);
try{
boolean getLock = distributedLockHandler.tryLock(lockKey, Long.valueOf(5));
if(getLock){
// Do your job
System.out.println("Do your job........");
}
}catch(Exception e){
System.out.println(e);
}finally {
distributedLockHandler.realseLock(lockKey);
}
}
}
三.实际使用
/**
* 获取锁
*
* @param key
* @param expireMillis 过期时间 单位毫秒
* @param timeoutMillis 获取锁超时时间 单位毫秒
* @return : boolean
*/
public boolean lock(String key, long expireMillis, long timeoutMillis) {
String lockKey = generateLockKey(key);
long start = System.currentTimeMillis();
try {
while ((System.currentTimeMillis() - start) < timeoutMillis) {
if(jimDBClient.set(lockKey, "0", expireMillis, TimeUnit.MILLISECONDS, false)) {
return true;
}
//加暂停时间防止活锁
TimeUnit.MILLISECONDS.sleep(redisLockSleepTime + RandomUtils.nextInt(0,100));
}
} catch (Exception e) {
logger.error("RedisLock 获取锁失败,KEY:"+key, e);
}
return false;
}
/**
* 组装锁的key
*
* @param key
* @return : java.lang.String
*/
private String generateLockKey(String key) {
return LOCK_KEY_PRE +key;
}
/**
* 释放锁
*
* @param key
* @return : void
*/
public void unlock(String key) {
String lockKey = generateLockKey(key);
try {
jimDBClient.del(key);
} catch (Exception e) {
logger.error("Redis锁解锁失败,key:{" + lockKey + "};", e);
}
}
调用demo:
public void demo() {
boolean isLocked = redisLock.lock(lockKey, redisLockExpireTime, redisLockTimeOut);
if(isLocked) {
try{
//业务逻辑
} catch (Exception e) {
throw e;
} finally {
redisLock.unlock(lockKey);
}
}else{
//如果获取锁失败则返回重试
logger.error("获取Redis锁失败,返回重试,Key:"+lockKey);
throw new RuntimeException("获取锁失败,返回重试,Key:"+lockKey) ;
}
}
四.结论
1.实际使用的是一个简易的分布式锁,主要目的是为了防止高并发导致的DB唯一索引频繁抛出异常导致死锁,(已经加乐观锁,但实际过程中依旧会出现频繁唯一索引冲突)
2.简易的分布式锁也并不是一个公平锁,但已经能解决上述死锁问题,所以未进行优化.
3.若实际生产中依旧出现问题,估计还会继续更新...