package com.doraemoney.core.utils;
import java.util.Random;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import com.google.common.collect.Maps;
import com.jfinal.log.Log;
/**
* Redis分布式锁<br>
* <p>注意事项:以key对应的资源加锁,</p>
* <b>用法一:</b>
* <p> Lock lock = new RedisLock("test",true);//获取资源锁</p>
<p> lock.lock();//加锁</p>
<p> 业务逻辑代码</p>
<p> lock.unlock();//释放锁</p>
* <b>用法二:</b>
* <p> Lock lock = RedisLock.getInstance("test", true);//获取资源锁,并缓存</p>
<p> lock.lock();//加锁</p>
<p> 业务逻辑代码</p>
<p> lock.unlock();//释放锁</p>
* @author ducongcong
* @date 2016年9月23日
*/
public class RedisLock implements Lock {
private static final Log logger = Log.getLog(RedisLock.class);
/**
* redis中锁住存储的值
*/
private static final String LOCKED = "LOCKED";
private static final String MODULE = "LOCK";
/**
* 30000毫秒内去设置redis,无法设置则
*/
private static final long TIME_OUT = 30000;
/**
* 失效时间 默认60s
*/
public static final int EXPIRE = 60;
/**
* 存储在redis中的key
*/
private String key;
/**
* 状态标志,=true 对应的key加锁成功
*/
private volatile boolean locked = false;
/**
* 存储锁对象(防止重复创建锁),根据具体业务
*/
private static ConcurrentMap<String, RedisLock> map = Maps.newConcurrentMap();
/**
* 设置锁的key
* @param key
*/
public RedisLock(String key){
this.key = CacheUtil.getKey(MODULE, key);
}
/**
* 设置锁的key
* @param key key
* @param isJoin 是否拼接
*/
public RedisLock(String key,boolean isJoin) {
if(isJoin){
this.key = CacheUtil.getKey(MODULE, key);
}else{
this.key = key;
}
}
/**
* 验证当前设置的key是否被锁住
* @return 返回true表示资源被锁,返回false表示资源空闲中
* @author ducongcong
* @createDate 2016年12月15日
* @updateDate
*/
public boolean isLock(){
String str = JedisUtil.get(this.key);
if(StringUtils.isNotEmpty(str)){
return Boolean.TRUE;
}
return Boolean.FALSE;
}
/**
* 获取针对key的锁,可以重复利用
* @param key
* @return
* @author ducongcong
* @createDate 2016年9月23日
* @updateDate
*/
public static RedisLock getInstance(String key,boolean isJoin) {
if(isJoin){
key = CacheUtil.getKey(MODULE, key);
}
RedisLock redisLock = map.get(key);
if(null == redisLock){
redisLock = new RedisLock(key,Boolean.TRUE);
map.put(key, redisLock);
}
return redisLock;
}
/**
* 加锁
* @param timeout
* @author ducongcong
* @createDate 2016年9月23日
* @updateDate
*/
public void lock(long timeout) {
long nano = System.nanoTime();
timeout *= 1000000;
final Random r = new Random();
try {
while ((System.nanoTime() - nano) < timeout) {
if (JedisUtil.setnx(key, LOCKED) > 0) {
JedisUtil.expire(key, EXPIRE);
locked = true;
logger.debug("add RedisLock[" + key + "].");
break;
}
Thread.sleep(3, r.nextInt(500));
}
} catch (Exception e) {
logger.error("",e);
}
}
@Override
public void lock() {
lock(TIME_OUT);
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit)
throws InterruptedException {
return false;
}
@Override
public void unlock() {
unlock(true);
}
/**
* 释放资源
* @param isClear 是否从map中清除 true清除(防止重复创建锁)
* @author ducongcong
* @createDate 2016年9月23日
* @updateDate
*/
public void unlock(boolean isClear) {
if (locked) {
logger.debug("release RedisLock[" + key + "].");
if(isClear){
//map中有就删除
map.remove(key);
}
JedisUtil.del(key);
}
}
@Override
public Condition newCondition() {
return null;
}
}
文章评论