Redis分布式锁的问题

Redis分布式锁的问题

分析车票超卖问题

@Service
public class TicketService {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public String productSoket(){
//        获取车票库存
        String ticket = stringRedisTemplate.opsForValue().get("ticket");
        int soket = Integer.parseInt(ticket);
//        判断库存是否大于0，如果大于0.则给库存减一
        if (soket > 0){
            soket = soket - 1 ;
            stringRedisTemplate.opsForValue().set("ticket",String.valueOf(soket));
            return "购买票成功"+soket ;
        }else{
            logger.info("车票已经卖完");
            return "车票已经卖完" ;
        }
    }
}
// 分析上述代码：在高并发环境下，在执行到  stringRedisTemplate.opsForValue().set("ticket",String.valueOf(soket));这个语句之前，有很多请求已经进入这个if语句，会出现余票成负数的问题，也就是说会出现超卖
//改进：加上同步锁 ，但是还有一个弊端，就是在高并发环境下，为了减少服务器的压力，会有多个相同的业务类，而同步锁，并不能锁住其他的相同的业务类，因此还是会出现超买问题
// 继续该进：使用我们呢的setnx命令，如果有一个请求进入到我们的服务器，我们马上使用这个命令，给服务器写入一条数据，表示已经有请求来到了这里，其他请求必须等待
@Service
public class TicketService {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    String  lock ;

    public synchronized String productSoket(){
        Boolean exist = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
        try {
            if (!exist){
                return "说明已经有买票的这个请求进入到服务器";
            }
//        获取车票库存
            String ticket = stringRedisTemplate.opsForValue().get("ticket");
            int soket = Integer.parseInt(ticket);
//        判断库存是否大于0，如果大于0.则给库存减一
            if (soket > 0){
                soket = soket - 1 ;
                stringRedisTemplate.opsForValue().set("ticket",String.valueOf(soket));
                return "购买票成功"+soket ;
            }else{
                logger.info("车票已经卖完");
                return "车票已经卖完";
            }
        } finally {
            stringRedisTemplate.delete(lock);
        }
    }
}
// 继续分析，如果程序执行到这里 Boolean exist = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");突然挂掉，那么后续的请求进来之后，都会返回false，这个时候，我们可以给这个lock设置一个过期时间，假如说，给这个key设置了30s的过期时间，但是30s后，程序还是没有执行完，那么第二个请求就会执行服务器的finally代码块，删除掉不属于他的这个key，因此，继续改进，设置键值对的时候，给定一个具有代表性的值，在最后进行判断，如果值相等，说明是同一个请求
public class TicketService {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    String  lock ;

    public  String productSoket(){
        String value = UUID.randomUUID().toString();
//       充分的利用了 redis和lua脚本  在C的层面上来实现原子性的a
//        expire 和 set 形成原子性
        Boolean exist = stringRedisTemplate.opsForValue().setIfAbsent(lock, value,30, TimeUnit.SECONDS);
        try {
            if (!exist){
                return "说明已经有买票的这个请求进入到服务器";
            }
//        获取车票库存
            String ticket = stringRedisTemplate.opsForValue().get("ticket");
            int soket = Integer.parseInt(ticket);
//        判断库存是否大于0，如果大于0.则给库存减一
            if (soket > 0){
                soket = soket - 1 ;
                stringRedisTemplate.opsForValue().set("ticket",String.valueOf(soket));
                return "购买票成功"+soket ;
            }else{
                logger.info("车票已经卖完");
                return "车票已经卖完";
            }
        } finally {
            if(value.equals(stringRedisTemplate.opsForValue().get(lock))){
                stringRedisTemplate.delete(lock);
            }
        }
    }
}
//这个程序，还有一个bug，如果一个请求在30s内没有执行完？使用后台线程进行续命，也叫做守护线程
@Service
public class TicketService {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

 	String  lock = "lock" ;

    public  String productSoket(){
        String value = UUID.randomUUID().toString();
//       充分的利用了 redis和lua脚本  在C的层面上来实现原子性的a
//        expire 和 set 形成原子性
        Boolean exist = stringRedisTemplate.opsForValue().setIfAbsent(lock, value,30, TimeUnit.SECONDS);
        //开一个守护线程
        MyThred myThread = new MyThred(lock);
        myThread.setDaemon(true);
        myThread.start();
        try {
            if (!exist){
//                让排队的人执行这个方法
                productSoket();
                return "说明已经有买票的这个请求进入到服务器";
            }
//        获取车票库存
            String ticket = stringRedisTemplate.opsForValue().get("ticket");
            int soket = Integer.parseInt(ticket);
//        判断库存是否大于0，如果大于0.则给库存减一
            if (soket > 0){
                soket = soket - 1 ;
                stringRedisTemplate.opsForValue().set("ticket",String.valueOf(soket));
                return "购买票成功"+soket ;
            }else{
                logger.info("车票已经卖完");
                return "车票已经卖完";
            }
        } finally {
            if(value.equals(stringRedisTemplate.opsForValue().get(lock))){
                stringRedisTemplate.delete(lock);
            }
        }
    }

    class MyThred extends  Thread{
        String lock;
        public MyThred(String lock){
            this.lock = lock;
        }
        @Override
        public void run() {
            while (true){
                //干这个事情、
                try{ 
                    Thread.sleep(10000);
                }catch (Exception err){

                }
                //假设程序还活着  那么说明需要续命
                stringRedisTemplate.expire(lock,30,TimeUnit.SECONDS);
            }
        }

    }
}

针对以上复杂的问题，redis提供了一个分布式锁的概念，来解决这个问题

基于redis的分布式锁问题的redisson的简单使用

1. 导包

		<!--导入redis分布式锁相关的包-->
		<dependency>
			<groupId>org.redisson</groupId>
			<artifactId>redisson</artifactId>
			<version>3.11.0</version>
		</dependency>

2.编写配置文件

@SpringBootConfiguration
public class RedisConfig {
    @Bean
    public RedissonClient redissonClient(){
        RedissonClient redissonClient = null;
        Config config = new Config();
//        设置请求的URl地址
        String url = "redis://192.168.1.12:6379";
//        设置config
       config.useSingleServer().setAddress(url);
//       通过redisson来创建一个客户端对象
        try {
            redissonClient = Redisson.create(config);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return redissonClient;
    }
}

3.编写lock类

@Component
public class DistributLock {

    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private RedissonClient redissonClient;

    /**
     * 加锁的方法
     * @param lockName
     * @return
     */
    public boolean Lock(String lockName){
        try {
            if (redissonClient==null){
                logger.info("枷锁失败");
                return false;
            }
//            如果对象注入，则加锁
            RLock lock = redissonClient.getLock(lockName);
            lock.lock(30, TimeUnit.SECONDS);
            logger.info("加锁成功");
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("发生不可预期的失误");
            return false;
        }
    }

    public boolean unLock(String lockName){
        try {
            if (redissonClient==null){
                logger.info("释放失败");
            }
//            获取锁
            RLock lock = redissonClient.getLock(lockName);
//            释放锁
            if (lock!=null){
                lock.unlock();
                return true;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

4.编写业务类

@Service
public class TicketService {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    String  lock = "lock" ;
    @Autowired
    private DistributLock distributLock;
    public String RedisProdcut(){
//        判断加锁是否成功
        boolean lock = distributLock.Lock(this.lock);
        try {
            if (lock){ //说明加锁成功
                //        获取车票库存
                String ticket = stringRedisTemplate.opsForValue().get("ticket");
                int soket = Integer.parseInt(ticket);
    //        判断库存是否大于0，如果大于0.则给库存减一
                if (soket > 0){
                    soket = soket - 1 ;
                    stringRedisTemplate.opsForValue().set("ticket",String.valueOf(soket));
                    return "购买票成功"+soket ;
                }else{
                    logger.info("车票已经卖完");
                    return "车票已经卖完";
                }
            }else {
                return "当前正在排队";
            }
        } finally {
            distributLock.unLock(this.lock);
        }
    }
}