015 redis分布式锁

古城微笑少年丶 2021-12-19 01:07 137阅读 0赞

## Redis分布式锁使用方法 ##

#### 1、背景 ####

*  为了防止用户操作重复提交，一般会在同一个业务代码判断是否已经存在了，但是在高并发环境下，上个事务还未提交，下个事务又进来了。这个时候就会出现两条数据都成功入库。 然后就引入了分布式锁。

#### 2、分布式锁实现方式 ####

*  通过lua表达式实现两个操作 1、setnx, 2、expire

#### 3、使用方法 ####

**引入redis操作**

@Autowired
    private RedisDistributedLock redisDistributedLock;

try {
    //获取锁	
        Boolean flag=redisDistributedLock.isPassConcurrentBarrier(MICRO_ADD_LOCK +entity.getCode(),"1",20);
        	if (flag) {
    	    //业务实现......
    	}else {
    	    //锁被占用放弃当前操作
        throw new throw new TiException("请稍后再试。");
    	}
    }finally {
    //释放锁
        redisDistributedLock.releaseBarrier(MICRO_ADD_LOCK+entity.getCode());
    }

#### 4.案例： ####

public static final String MICRO_ADD_LOCK = "microAddLock:";
        
        @Autowired
        private RedisDistributedLock redisDistributedLock;

@Override
        public void modifyInfo(MicroServicesEntity entity,String token) {
            Map<String,String> userMap = (Map<String, String>) authService.getUserInfoByToken(token).get("userInfo");
            Example example=new Example(entity.getClass());
            example.createCriteria().andEqualTo("code",entity.getCode())
                    .orEqualTo("name",entity.getName());
            List<MicroServicesEntity> check= microServicesDao.selectByExample(example);
            try {
                Boolean flag=redisDistributedLock.isPassConcurrentBarrier(MICRO_ADD_LOCK +entity.getCode(),"1",20);
                if (flag) {
                    if (StringUtils.isEmpty(entity.getId())) {
                        if (check != null && check.size() > 0) {
                            throw new TiException("系统已存在相同的服务名字或代码");
                        }
                        entity.setCreateTime(new Date());
                        entity.setUpdateTime(new Date());
                        entity.setUpdateBy(userMap.get("account"));
                        entity.setCreateBy(userMap.get("account"));
                        entity.setStatus(MicroServicesEntity.USE_STATUS);
                        entity.setId(UUID.randomUUID().toString());
                        entity.setSecert(UUIDUtils.generateShortUuid());
                        microServicesDao.insertSelective(entity);
                    } else {
                        if (check != null && check.size() > 0) {
                            for (MicroServicesEntity servicesEntity : check) {
                                if (!servicesEntity.getId().equals(entity.getId())) {
                                    throw new TiException("系统已存在相同的服务名字或代码");
                                }
                            }
                        }
                        entity.setUpdateTime(new Date());
                        entity.setUpdateBy(userMap.get("account"));
                        microServicesDao.updateByPrimaryKeySelective(entity);
                    }
                }else {
                    throw new TiException("请稍后再试。");
                }
            }finally {
                redisDistributedLock.releaseBarrier(MICRO_ADD_LOCK+entity.getCode());
            }
        }

## 其他 ##

*  RedisDistributedLock.java

package com.epf.common.utils;
    
    import com.tiaim.framework.exception.TiException;
    import org.apache.commons.lang.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.stereotype.Component;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 分布式锁
     * @author quanjs
     */
    @Component
    public class RedisDistributedLock {
        private Logger logger = LoggerFactory.getLogger(RedisDistributedLock.class);
        @Autowired
        private RedisTemplate<String,Object> template;
        private List<String> putList(String... args) {
            List<String> list = new ArrayList<>();
            if (args != null) {
                for (String value : args) {
                    list.add(value);
                }
            }
            return list;
        }
    
        /**
         * 通过lua表达式  实现两个操作 1、setnx 2、expire 实现
         * @param key
         * @param value  存的值
         * @param timeOut 自动解锁时间 秒
         * @return  true 可使用 false 不可使用 业务未完成
         */
        public boolean isPassConcurrentBarrier(String key, String value, Integer timeOut) {
            if (timeOut==null||timeOut==0 || StringUtils.isBlank(key)|| StringUtils.isBlank(value)) {
                throw new TiException("获取锁参数非法");
            }
            final String luaScript = " "
                    + " local result = tonumber(redis.call('SETNX', KEYS[1],ARGV[1]));"
                    + " if result==0 then "
                    + " return result;"
                    + " end "
                    + " redis.call('EXPIRE',KEYS[1],ARGV[2]);" + " return result";
    
            final List<String> keys = putList(key);
            DefaultRedisScript<Object> getRedisScript = new DefaultRedisScript<>();
            getRedisScript.setResultType(Object.class);
            getRedisScript.setScriptText(luaScript);
            ArrayList<Long> result =  (ArrayList)template.execute(getRedisScript, keys, value,timeOut);
            if (result.get(0) == 0) {
                logger.info("redis result is {}",false);
                return false;
            }
            logger.info("redis result is {}",true);
            return true;
        }
    
    
        public void releaseBarrier(String key){
            template.delete(key);
        }
    
    }