redis分布式锁源码

雨点打透心脏的1/2处 2022-12-28 11:16 147阅读 0赞

public class DistributeLockByRedis implements DistributeLock {
    
    	private static Logger log = LoggerFactory.getLogger(DistributeLockByRedis.class);
    	
    	private static final Long RELEASE_SUCCESS = 1L;
    	private static final String RELEASE_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    	private static final String LOCK_SUCCESS = "OK";
    	private static final String SET_IF_NOT_EXIST = "NX";
    	private static final String SET_WITH_EXPIRE_TIME = "PX"; //毫秒数
    	
    	public int lock(String key, String uniqueId, long expireTime) throws LockException
    	{
    		return lock(key, uniqueId, expireTime, false, 0);
    	}
    	
    	public int lock(String key, String uniqueId, long expireTime, boolean isThreadBlocking, long threadBlockingTime) throws LockException
    	{
    		if(RobotUtils.isEmpty(key))
    		{
    			log.error("key不能为空！");
    			throw new LockException("key不能为空！");
    		}
    		if(RobotUtils.isEmpty(uniqueId))
    		{
    			log.error("uniqueId不能为空！");
    			throw new LockException("uniqueId不能为空！");
    		}
    		if(expireTime <= 0)
    		{
    			log.error("expireTime不能小于或等于0！");
    			throw new LockException("expireTime不能小于或等于0！");
    		}
    		
    		DataCache dataCache = DataCacheFactory.getInstance();
    		
    		String setResult = "";
    		int applyLockResult = LockResult.SUCCESS.getCode();
    		long blockStartTime = System.currentTimeMillis();	//开始阻塞的时间
    		long blockTotalTime = 0;
    		
    		do
    		{
    			try
    			{
    				setResult = dataCache.setNx(key, uniqueId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
    			}
    			catch(Exception e)
    			{
    				String errStr = "获取redis分布式锁【key：" + key + "，uniqueId：" + uniqueId + "】时失败，原因：" + e.getMessage();
    				log.error(errStr, e);
    				throw new LockException(errStr, e.getCause());
    			}
    			
    			if(!RobotUtils.isEmpty(setResult) && setResult.equals(LOCK_SUCCESS))
    			{
    				//成功获得锁
    				applyLockResult = LockResult.SUCCESS.getCode();
    				break;
    			}
    			else
    			{
    				//设置锁失败
    				applyLockResult = LockResult.FAIL.getCode();
    				
    				if(isThreadBlocking)
    				{
    					try
    					{
    						//当前已设置为失败时阻塞线程来等待，所以阻塞当前线程200毫秒
    						Thread.sleep(200);
    					}
    					catch(Exception e)
    					{
    						log.error("阻塞当前线程失败！原因：" + e.getMessage(), e);
    						throw new LockException("阻塞当前线程失败！", e.getCause());
    					}
    				}
    			}
    			
    			//计算已消耗时长
    			blockTotalTime = System.currentTimeMillis() - blockStartTime;
    		}
    		//需要阻塞当前线程 && 没有获取到锁 && 阻塞时间没有超过设定的时长
    		while(isThreadBlocking && applyLockResult != LockResult.SUCCESS.getCode() && threadBlockingTime > blockTotalTime);
    		
    		//需要阻塞当前线程 && 阻塞时间已超时 && 没有获取到锁
    		if(isThreadBlocking && threadBlockingTime <= blockTotalTime && applyLockResult != LockResult.SUCCESS.getCode())
    		{
    			//在规定时间内没有获取到锁，则修改返回值为失败且已超时
    			applyLockResult = LockResult.FAIL_TIMEOUT.getCode();
    		}
    		
    		return applyLockResult;
    	}
    	
        public boolean unlock(String key, String uniqueId)
        {
        	if(RobotUtils.isEmpty(key))
    		{
    			log.error("key不能为空！");
    		}
        	if(RobotUtils.isEmpty(uniqueId))
        	{
        		log.error("uniqueId不能为空！");
        	}
        	DataCache dataCache = DataCacheFactory.getInstance();
        	
        	try
        	{
        		Object result = dataCache.eval(RELEASE_SCRIPT, key, uniqueId);
        		if(RELEASE_SUCCESS.equals(result))
        		{
        			//成功释放锁
        			return true;
        		}
        	}
        	catch(Exception e)
        	{
        		String errStr = "释放锁【key：" + key + "，uniqueId：" + uniqueId + "】失败，原因：" + e.getMessage();
        		log.error(errStr, e);
        	}
        	
        	//锁释放失败，redis在key超时时会自行销毁该key
        	return false;
        }
        
    }