在项目中的锁的操作_非分布式Redis锁

布满荆棘的人生 2022-02-13 15:47 141阅读 0赞

总结：  
这个锁 的原理就是，建立一个中间表，在执行重要的跟新插入操作或查询操作，前先把 封装数据的类名，和单据id 存进数据库。执行完记得删除这个锁记录。  
获取锁就是，用这两个条件去查，如果查到就证明这个单据正在被别人使用，就是获取锁失败，请抛异常； 如果没查这条锁，就证明这条记录没人用，那就先插入这条数据，这样获取锁就操作成功

获取锁  
这个获取锁的方法的 参数 第一个是 封装数据的实体类entity的类名，第二个参数就是这张单的 单据号

applicationLockService.acquireMutexLockNoWait(InvWXXXXXead.class.getName(), headid + "");

获取锁的方法  
这里有两种  
一种不会造成线程阻塞，这个没有强调必须在一个事务(比如分布式环境下的feign或Facade\[这个facade可以理解为dubbo分布式系统web层的接口掉service层用的\])。  
一种 不会造成线程阻塞，必须强调在一个事务里面(比如dubbo分布式系统的service层)。

先介绍 可能造成线程阻塞的 获取锁的方法

/**
    	 *  过账单据前时使用的互斥的锁
    	
    	 *  
    	 *  警告：请保证在finally中调用releaseMutexLockNoWait释放锁
    	 *  
    	 * acquireLock no Wait 
    	 * @param serviceId entity class name
    	 * @param lockKey table unique id
    	 * @throws Exception
    	 */
    	@Override
    	public ApplicationLock acquireMutexLockNoWait(final String serviceId, final String lockKey) throws Exception {
    		if (serviceId== null || lockKey==null) {
    			throw new IllegalArgumentException("serviceId和lockKey不能为空");
    		}		
    		//查询单是否已经处理记录
    		ApplicationLock lockRecord = null;
    		try {
    			lockRecord = applicationLockMapper.acquireMutexLockNoWait(serviceId, lockKey);
    		} catch (Exception ex) {
    			logger.debug("查询锁失败：" + serviceId + '-' + lockKey);
    			logger.error("查询锁失败：" + serviceId + '-' + lockKey, ex);
    			throw ex;
    		}
    		
    		if(lockRecord!=null){
    			throw new Exception("单据已经被其他人处理，请刷新页面");
    		}else{			
    			try {
    				int effectCount=this.insertLockRecord(serviceId, lockKey); 	
    				if(effectCount>0){
    					lockRecord=new ApplicationLock();
    					lockRecord.setServiceId(serviceId);
    					lockRecord.setLockKey(lockKey);
    				}
    			} catch(Exception ex) { //如果已经插入记录,会捕捉到duplicate Key异常
    				logger.debug("插入数据失败, 已经有记录" + serviceId + '-' + lockKey);
    				logger.error("插入数据失败, 已经有记录" + serviceId + '-' + lockKey, ex);
    				throw new Exception("单已经被其他人处理，请刷新页面");
    			}
    		}		
    		logger.debug("获取锁成功：" + serviceId + '-' + lockKey);
    		return lockRecord;
    	}

/**
    	 * insert in new transaction
    	 * 
    	 * 定义新事务
    	 * 插入一个新的锁记录必须 先开启一个新的事务，
    	 * 由于 spring配置切片式事务，不必使用事务注解
    	 * 
    	 * @param serviceId entity class name
    	 * @param lockKey table unique id
    	 * 
    	 */
    	private int insertLockRecord(final String serviceId, final String lockKey) {
    		
    		ApplicationLock lock = new ApplicationLock();
    		lock.setLockKey(lockKey);
    		lock.setServiceId(serviceId);
    		return applicationLockMapper.insertLockRecord(lock);
    	}

这个方法的mapper.xml 文件

<select id="acquireMutexLockNoWait" resultMap="baseResultMap" >
    	 select * from app_lock
        where LOCK_KEY = #{lockKey,jdbcType=VARCHAR}
        and SVC_ID = #{serviceId,jdbcType=VARCHAR}
      </select>

这里的 select ，Oracle是不会加任何锁的，也就是Oracle对 select 读到的数据不会有任何限制，虽然这时候有可能另外一个进程正在修改表中的数据，并且修改的结果可能影响到你目前select语句的结果，但是因为没有锁，所以select结果为当前时刻表中记录的状态。

<insert id="insertLockRecord" parameterType="com.XXX.XXX.XXX.utils.lock.ApplicationLock" >
      	<selectKey keyProperty="lockId" order="BEFORE" resultType="java.lang.Integer">
                select -SQ_APP_LOCK.nextval from dual
            </selectKey>
        insert into app_lock (
        	LOCK_ID, 
        	SVC_ID, 
        	LOCK_KEY, 
        	LAST_UPDATE_DATE
        ) 
        values (
        	#{lockId,jdbcType=INTEGER},
        	#{serviceId,jdbcType=VARCHAR},
        	#{lockKey,jdbcType=VARCHAR},
        	sysdate
        )    
      </insert>

第一种获取锁的方法结束

第二种 获取锁的方法

/**
    	 * 
    	 * 获取行锁, 如果获取失败, 说明已经有其他线程已经占用, 将会抛出异常(ConcurrencyFailureException ORA-00054:资源正忙)
    	 * 如果已经有其他线程占用了该锁, 该方法不会导致当前执行线程阻塞
    	 * （保证调用此方法时已经有事务）
    	 * 
    	 * @param serviceId entity class name
    	 * @param lockKey table unique id
    	 * @throws Exception
    	 */
    	@Override
    	@Transactional(propagation = Propagation.REQUIRED)
    	public ApplicationLock acquireLockNoWait(final String serviceId, final String lockKey) {
    	    if (serviceId== null || lockKey==null) {
                throw new IllegalArgumentException("serviceId和lockKey不能为空");
            }
            
            ApplicationLock lockRecord = null;
            try {
                lockRecord = applicationLockMapper.acquireLockNoWait(serviceId, lockKey);
            } catch (Exception ex) {
                logger.debug("获取锁失败：" + serviceId + '-' + lockKey);
                logger.error("获取锁失败：" + serviceId + '-' + lockKey, ex);
                throw ex;
            }
    
            if (lockRecord == null) {
                logger.debug("锁记录不存在，将尝试插入锁：" + serviceId + '-' + lockKey);
                
                try {
                    this.insertLockRecord(serviceId, lockKey); //在新事物中
    
                } catch(Exception ex) { //如果已经插入记录,会捕捉到duplicate Key异常，再尝试获取一次行锁
                    logger.debug("插入数据失败, 已经有记录，将重新获取锁：" + serviceId + '-' + lockKey);
                    logger.error("插入数据失败, 已经有记录，将重新获取锁：" + serviceId + '-' + lockKey, ex);
                }
                
                lockRecord = applicationLockMapper.acquireLockNoWait(serviceId, lockKey);  //将会抛出异常 ORA-00054:资源正忙
                
                if(lockRecord == null) { //仍然获取失败抛出异常
                    logger.debug("找不到行锁记录，获取失败:" + serviceId + '-' + lockKey);
                    throw new ApplicationException("找不到行锁记录，获取失败:" + serviceId + '-' + lockKey);
                }
            }
            
            logger.debug("获取锁成功：" + serviceId + '-' + lockKey);
            return lockRecord;
    	}

这个this.insertLockRecord 方法参考上面

<select id="acquireLockNoWait" resultMap="baseResultMap" >
        select * from app_lock
        where LOCK_KEY = #{lockKey,jdbcType=VARCHAR}
        and SVC_ID = #{serviceId,jdbcType=VARCHAR}
        for update nowait
      </select>

这个 Oracle 的 select 查询  
注意 for update nowait  
就是这个Oracle 的关键词 不会造成等待，如果另外一个线程正在修改结果集中的数据，**select…for update nowait** 不会进行资源等待(如果是 **select…for update**则会陷入等待)，只要发现结果集中有些数据被加锁，立刻返回“ORA-00054错误，内容是资源正忙, 但指定以 NOWAIT 方式获取资源”。这个抛异常 就需要保证操作在一个事务里面，所以前提是在事务里面。

删除锁的办法

这个没强调非得在一个事务里面

/**
    	 *  单据操作失败后释放掉互斥的锁
    	 * acquireLock no Wait 
    	 * @param serviceId entity class name
    	 * @param lockKey table unique id
    	 * @throws Exception
    	 */
    	@Override
    	public Integer releaseMutexLockNoWait(String serviceId,
                                              String lockKey) throws Exception {
    		//单据处理失败
    		if (serviceId== null || lockKey==null) {
    			throw new IllegalArgumentException("serviceId和lockKey不能为空");
    		}		
    		//查询单据是否已经处理记录
    		Integer lockRecord = null;
    		try {
    			lockRecord = applicationLockMapper.releaseLockNoWait(serviceId, lockKey);
    		} catch (Exception ex) {
    			logger.debug("释放锁失败：" + serviceId + '-' + lockKey);
    			logger.error("释放锁失败：" + serviceId + '-' + lockKey, ex);
    			throw ex;
    		}
    		return lockRecord;
    	}