聊一聊对用Redis实现分布式锁的理解(基于setnx和基于Redisson的尝试)

减库存业务为防止超卖，怎么做？可以使用synchronized加锁分布式环境下synchronized失效，因为synchronized是单JVM下保证锁，怎么做?使用Redis的setnx命令,如果能修改key返回true，说明获取到key，加锁成功，最后将key删掉，便于下个减库存。业务出现异常，没有释放锁(删掉key)怎么办？使用try catch finally ，在finally中删掉k

May Hacker

1854人浏览 · 2021-02-22 12:31:18

May Hacker · 2021-02-22 12:31:18 发布

文章目录

减库存业务

使用两台Nginx + 两个Tomcat进行负载均衡，模拟分布式，Redis使用单机实例。

压测工具：Jmeter

库存数据保存在Redis中
在这里插入图片描述
这里使用springboot 整合 Redis

/**
 * @author 阳光大男孩！！！
 */
@RestController
@RequestMapping("order")
@Slf4j
@RequiredArgsConstructor
public class orderController {

    private final StringRedisTemplate stringRedisTemplate;
    
    @RequestMapping("/deduceStock")
    public RespBean deduceOrder()
    {
        String s = stringRedisTemplate.opsForValue().get("stock");
        if(s==null)
        {
            return RespBean.error("请求失败");
        }
        int stock =Integer.parseInt(s) ;
        if(stock>0)
        {
            stringRedisTemplate.opsForValue().set("stock",String.valueOf(stock-1));
            System.out.println("扣减库存成功,剩余库存"+(stock-1));
            return RespBean.ok("扣减库存成功");
        }else
        {
            System.out.println("扣减库存失败，余额不足");
            return RespBean.ok("扣减库存失败");
        }

    }
}

可以看出来这是一段问题代码，当并发情况下，会导致超卖。

为防止超卖，怎么做？

可以使用synchronized加锁

synchronized问题在哪？

分布式环境下synchronized失效，因为synchronized是单JVM下保证锁。

当分布式情况下，两台实例时，依旧会导致问题。

在通过nginx负载均衡后，可以看到两个实例出现了相同的“剩余库存”，这就会超卖
在这里插入图片描述

在这里插入图片描述

那应该怎么做?

使用Redis的setnx命令,Redis Setnx（SET if Not eXists）命令在指定的 key 不存在时，为 key 设置指定的值。

如果能修改key返回true，说明获取到key，加锁成功，最后将key删掉，便于下个减库存。

  Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "");
  if(!lock){
      return RespBean.error("请重试");
  }

业务出现异常，没有释放锁(删掉key),怎么办？

使用try catch finally ，在finally中删掉key

中途宕机的话锁就不会被释放，中途宕机怎么办？

解决方案可以是加锁时，给key设置过期时间。

如果在加锁后，设置过期时间之前，挂了，依然不会解决问题，怎么办

set命令可以支持同时设置key和过期时间，即setnx+expire，redis可以保证原子性，或者使用LUA脚本保证setnx+expire命令的原子性。

set key value [EX seconds] [PX milliseconds] [NX|XX]
EX seconds：设置失效时长，单位秒
PX milliseconds：设置失效时长，单位毫秒
NX：key不存在时设置value，成功返回OK，失败返回(nil)
XX：key存在时设置value，成功返回OK，失败返回(nil)

案例：设置name=p7+，失效时长100s，不存在时设置
1.1.1.1:6379> set name p7+ ex 100 nx

当执行请求时，执行请求时间过长，键过期了，其他请求就会过来加锁，执行减库存，那么就会出现锁失效问题，怎么办？

可以使用watch dog 机制，开启子线程，每隔一段时间，判断锁是否还存在，如果还存在，那么就延长锁的时间。

实现Redis分布式锁

可以基于Redission实现分布式锁

 <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.14.1</version>
 </dependency>

将redisson交给Spring管理

/**
 * @author 阳光大男孩！！！
 */
@Configuration
public class RedissonConfig {
    @Bean
    public RedissonClient getRedission()
    {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        return Redisson.create(config);

    }
}

用Redisson实现分布式锁，最基本的使用就是三板斧

// 获取锁
RLock lock = redissonClient.getLock("lock");
// 加锁
lock.lock();
// 解锁
lock.unlock();

将上面的减库存改一下

/**
 * @author 阳光大男孩！！！
 */
@RestController
@RequestMapping("order")
@Slf4j
@RequiredArgsConstructor
public class orderController {

    private final StringRedisTemplate stringRedisTemplate;

    private final RedissonClient redissonClient;

    @RequestMapping("/deduceStock")
    public RespBean deduceOrder() {
        // 获取锁
        RLock lock = redissonClient.getLock("lock");
        // 加锁
        lock.lock();
        try {
            // 获取库存
            String s = stringRedisTemplate.opsForValue().get("stock");
            if (s == null) {
                return RespBean.error("请求失败");
            }
            int stock = Integer.parseInt(s);
            // 减库存
            if (stock > 0) {
                stringRedisTemplate.opsForValue().set("stock", String.valueOf(stock - 1));
                System.out.println("扣减库存成功,剩余库存" + (stock - 1));
            } else {
                System.out.println("扣减库存失败，余额不足");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return RespBean.ok("请求成功");
    }
}