基于redis的分布式锁

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;
	}

}