使用Redis实现分布式锁解决商品超卖问题

已于 2023-10-21 16:07:35 修改
阅读量736 收藏 12
点赞数 2
文章标签： redis 分布式 数据库
于 2023-10-20 22:31:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54187478/article/details/133952595
版权

1.业务描述

模拟一个商品的下订单业务。
用户下订单

第一步：用户单击下单接口
在这里插入图片描述
第二步：执行下单业务

  1. 先从Redis总获取库存，判断库存是否充足
    在这里插入图片描述
    在这里插入图片描述

  2. 当库存>=下单数量时

在这里插入图片描述

	扣减库存
	下单成功
	扣减库存

在这里插入图片描述

  1. 当库存<下单数量时
    在这里插入图片描述

    库存不足
下单失败

2.超卖问题

商品超卖是指在电子商务系统或其他销售系统中，某个商品的库存数量被错误地减少到负数，导致卖出的商品数量超过了实际库存数量。这是一个常见的问题，特别是在高并发的情况下，可能会出现多个用户同时购买同一件商品，而系统没有正确处理这种竞争条件，导致超卖。
超卖问题可能会导致以下不良后果：

  • 库存不准确：超卖会导致库存数量不准确，系统显示的库存与实际库存不一致。

  • 用户体验差：用户购买的商品实际上已经售罄，但系统仍然接受订单，这会给用户带来不满和失望。

  • 损失和纠纷：商家需要履行超卖订单，或者退款给用户，这可能导致商家的损失和用户不满，甚至引发纠纷。

为了解决商品超卖问题，可以采取以下一些策略：
锁定库存：在用户下单时，首先锁定相应数量的库存。这可以通过分布式锁或数据库事务来实现。锁定库存后，其他用户将无法购买相同商品，直到订单完成或取消。

  • 扣减库存原子操作：扣减库存应当是一个原子操作，确保只有一个线程可以修改库存数量。这可以通过数据库事务或原子性的内存操作来实现。

  • 超卖检测：在扣减库存时，需要检查库存是否足够。如果库存不足，应拒绝订单或采取其他措施，而不是扣减库存。

  • 队列管理：使用队列来处理订单，确保每个订单按照先后顺序进行处理。这可以避免竞争条件。

  • 库存同步：定期或实时同步库存数量，确保库存数量准确。

  • 使用分布式锁：在分布式系统中，使用分布式锁可以避免不同节点之间的竞争条件。

解决商品超卖问题需要综合考虑业务逻辑、并发控制和系统架构等因素，以确保系统的高可用性和数据一致性。

3.使用Redis分布式锁解决

3.1 版本1

定义一个锁，尝试使用锁来控制多线程并发，实现多个线程同步访问Redis库，解决了单体项目超卖问题。

public String sale1(int count){
        String retMessage = "";
        lock.lock();
        try{
            // 1.查询库存
            String resultFromRedis=stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            lock.unlock();
        }
        return retMessage;
    }

缺点：无法解决分布式环境下产品超卖问题。

3.2 版本2

利用Redis的setnx命令，实现分布式锁，以递归的方式重试，解决了分布式环境下商品超卖问题。

public String sale2(int count){
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        // 尝试获取
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, value);
        if(!flag){
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 递归尝试获取锁
            sale2(count);
        }else{
            try{
                // 1.查询库存
                String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
                // 判断库存是否足够
                Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
                if(num-count > 0){
                    stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                    retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                    System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");

                }else{
                    retMessage="商品已售罄！非常抱歉！";
                    System.err.println(retMessage);
                }
            }finally {
                stringRedisTemplate.delete(key);
            }
        }
        return retMessage;
    }

缺点：由于使用了递归调用，当持有锁的线程，长时间未释放锁时，容易出现栈溢出。

3.3 版本3

利用Redis的setnx命令，实现分布式锁，以自旋的方式重试，解决了版本2中的栈溢出问题。

public String sale3(int count){
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        // 循环尝试获取
        while(!stringRedisTemplate.opsForValue().setIfAbsent(key, value)){
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
        }
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            stringRedisTemplate.delete(key);
        }
        return retMessage;
    }

缺点：当持有锁的微服务宕机时，锁没法释放，导致后面微服务无法获取锁。

3.4 版本4

在版本3的基础上，加入key的过期时间，解决了版本3出现的微服务无法获取锁的问题。

public String sale4(int count){
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        // 循环尝试获取
        while(!stringRedisTemplate.opsForValue().setIfAbsent(key, value)){
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
        }
        //设置过期时间
        stringRedisTemplate.expire(key,30L,TimeUnit.SECONDS);
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            stringRedisTemplate.delete(key);
        }
        return retMessage;
    }

缺点：加锁和设置过期时间不是原子操作，出现原子问题

3.5 版本5

在版本4的基础上，加锁和设置时间使用一条原子命令，解决了版本4的问题

public String sale5(int count){
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        // 循环尝试获取
        while(!stringRedisTemplate.opsForValue().setIfAbsent(key, value,30L,TimeUnit.SECONDS)){
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
        }
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            stringRedisTemplate.delete(key);
        }
        return retMessage;
    }

缺点：由于多线程并发，引入误删除锁问题

3.6 版本6

只允许自己删除自己的锁，不可以删除别人添加的锁。

public String sale6(int count){
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        // 循环尝试加锁
        while(!stringRedisTemplate.opsForValue().setIfAbsent(key, value,30L,TimeUnit.SECONDS)){
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
        }
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            //删除之前判断下是不是自己加的锁
            if(stringRedisTemplate.opsForValue().get(key).equalsIgnoreCase(value)){
                stringRedisTemplate.delete(key);
            }
        }
        return retMessage;
    }

缺点：判断是不是自己的锁和删除操作不具有原子性

3.7 版本7

使用lua脚本解决版本6出现的问题。

 public String sale7(int count){
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        // 循环尝试加锁
        while(!stringRedisTemplate.opsForValue().setIfAbsent(key, value,30L,TimeUnit.SECONDS)){
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
        }
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            //lua脚本：先判断一个key的value是否跟预期的一样，一样的话就删除这个key，否则什么也不做
            // if(条件) then //小括号可省略
            //   业务代码
            // elseif(条件) then
            //   业务代码
            // elseif(条件) then
            //   业务代码
            // elseif(条件) then
            //   业务代码
            // ...
            // else
            //   业务代码
            // end  //if终止符
            // eval "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end" 1 lock-test 112233
            // lua脚本执行语法：EVLA "脚本" 参数
            //删除之前判断下是不是自己加的锁
            String lua_script=
                    "if redis.call('get',KEYS[1]) == ARGV[1] " +
                            "then return redis.call('del',KEYS[1]) " +
                            "else " +
                            "return 0 " +
                            "end";
            stringRedisTemplate.execute(new DefaultRedisScript<>(lua_script, Boolean.class), Arrays.asList(key), value);
        }
        return retMessage;
    }

缺点：当业务方法调用其他方法且其他方法需要加分布式锁的时候，未考虑可重入性，这个时候会其他方法也会尝试加锁。

3.8 版本8

考虑可重入性,维护一个重入度，使用hset key value recount，为了保证多个命令原子性，使用lua脚本。

public String sale8(int count){
        // 加锁的lua脚本，等价于lock方法
//     if(redis.call('exist',KEY[1],ARGV[1]) == 0 or redis.call('hexist',KEY[1],ARGV[1]) == 1) then
//            redis.call('hincrby',KEY[1],ARGV[1],1)
//            redis.call('expire',KEY[1],ARGV[2])
//            return 1
//      else
//        return 0
//     end

        // 解锁的lua脚本，等价于unlock方法
//     if(redis.call('exist',KEY[1],ARGV[1]) ==0 ) then
//        return nil
//     elseif(redis.call('hincrby',KEY[1],ARGV[1],-1) == 0) then
//        return redis.call('del',KEY[1])
//     else
//        return 0
//     end
        String retMessage = "";
        String key = "redis-lock";
        String value = UUID.randomUUID()+":"+Thread.currentThread().getId();
        Integer expireTime = 50;
        String lua_lock="if(redis.call('exist',KEY[1],ARGV[1]) == 0 or redis.call('hexist',KEY[1],ARGV[1]) == 1) then" +
                "            redis.call('hincrby',KEY[1],ARGV[1],1)" +
                "            redis.call('expire',KEY[1],ARGV[2])" +
                "            return 1" +
                "        else" +
                "            return 0" +
                "        end";
        // 循环尝试加锁
        while(!stringRedisTemplate.execute(new DefaultRedisScript<>(lua_lock, Boolean.class), Arrays.asList(key), value, String.valueOf(expireTime))){
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
        }
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            String lua_unlock="if(redis.call('exist',KEY[1],ARGV[1]) ==0 ) then" +
                    "             return nil" +
                    "          elseif(redis.call('hincrby',KEY[1],ARGV[1],-1) == 0) then" +
                    "             return redis.call('del',KEY[1])" +
                    "          else" +
                    "             return 0" +
                    "          end";
            stringRedisTemplate.execute(new DefaultRedisScript<>(lua_unlock, Long.class), Arrays.asList(key), value);
        }
        return retMessage;
    }

缺点：耦合度高

3.9 版本9

将锁封装为一个类，实现Lock规范，降低耦合

 private MyRedisLock myRedisLock = new MyRedisLock(stringRedisTemplate,"redis-lock");
 public String sale9(int count){
        String retMessage = "";
        myRedisLock.tryLock();
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            myRedisLock.unlock();
        }
        return retMessage;
    }

自定义锁实现Lock接口

public class MyRedisLock implements Lock {

    private StringRedisTemplate stringRedisTemplate;
    private String key;
    private String value;
    private long expireTime;

    public MyRedisLock(StringRedisTemplate stringRedisTemplate, String key,String value) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.key = key;
        this.value= value;
        this.expireTime = 50L;
    }

    public MyRedisLock(StringRedisTemplate stringRedisTemplate, String key) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.key = key;
        this.value= UUID.randomUUID()+":"+Thread.currentThread().getId();
        this.expireTime = 50L;
    }

    @Override
    public void lock() {
        tryLock();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        try {tryLock(-1L, TimeUnit.MILLISECONDS);} catch (InterruptedException e) {e.printStackTrace();}
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if(time == -1){
            String lua_lock="if(redis.call('exist',KEY[1],ARGV[1]) == 0 or redis.call('hexist',KEY[1],ARGV[1]) == 1) then" +
                    "            redis.call('hincrby',KEY[1],ARGV[1],1)" +
                    "            redis.call('expire',KEY[1],ARGV[2])" +
                    "            return 1" +
                    "        else" +
                    "            return 0" +
                    "        end";
            while(!stringRedisTemplate.execute(new DefaultRedisScript<>(lua_lock,Boolean.class), Arrays.asList(key),value,String.valueOf(expireTime))){
                TimeUnit.MILLISECONDS.sleep(50);
            }
            System.out.println("锁的名字："+key);
            return true;
        }
        return false;
    }

    @Override
    public void unlock() {
        String lua_unlock="if(redis.call('exist',KEY[1],ARGV[1]) ==0 ) then" +
                "             return nil" +
                "          elseif(redis.call('hincrby',KEY[1],ARGV[1],-1) == 0) then" +
                "             return redis.call('del',KEY[1])" +
                "          else" +
                "             return 0" +
                "          end";
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(lua_unlock, Long.class), Arrays.asList(key), value);
        System.out.println("锁的名字："+key);
        if(null == flag){
            throw new RuntimeException("当前锁不存在！");
        }
    }

    @Override
    public Condition newCondition() {
        return null;
    }

}

缺点：通用性不好

3.10 版本10

引入工厂模式,实现通配型

@Autowired
    private MyLockFactory myLockFactory1;
    public String sale10(int count){
        Lock myRedisLockFromFactory = myLockFactory1.getLock("REDIS");
        String retMessage = "";
        myRedisLockFromFactory.tryLock();
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            myRedisLockFromFactory.unlock();
        }
        return retMessage;
    }

工厂类：

@Component
public class MyLockFactory {

    private String key;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private String value;

    public MyLockFactory() {
        this.value = UUID.randomUUID()+":"+Thread.currentThread().getId();
    }

    public Lock getLock(String lockType){
        if(lockType == null) return null;
        if(lockType.equalsIgnoreCase("REDIS")){
            this.key="redis-lock";
            return new MyRedisLock(stringRedisTemplate,key,value);
        }else if(lockType.equalsIgnoreCase("ZOOKEEPER")){
            this.key="zookeeper-lock";
            return null;//返回zookeeper版本的分布式锁
        }else if(lockType.equalsIgnoreCase("MYSQL")){
            this.key="zookeeper-lock";
            return null;//返回MySQL版本的分布式锁
        }else
            return null;
    }
}

缺点：没有自动续期

3.11 版本11

定时任务+lua脚本实现自动续期

@Autowired
    private MyLockFactory myLockFactory2;
    public String sale11(int count){
        // 自动续期脚本
//         if(redis.call('hexists',KEY[1],ARGC[1] ==1 ) then
//            return redis.call('expire',KEY[1],ARGV[2])
//         else
//            return 0;
//         end
        Lock myRedisLockFromFactory = myLockFactory2.getLock("REDIS");
        String retMessage = "";
        myRedisLockFromFactory.tryLock();
        try{
            // 1.查询库存
            String resultFromRedis = stringRedisTemplate.opsForValue().get(key);
            // 判断库存是否足够
            Integer num=resultFromRedis == null?0:Integer.parseInt(resultFromRedis);
            if(num-count > 0){
                stringRedisTemplate.opsForValue().set(key,String.valueOf(--num));
                retMessage = "成功卖出"+count+"件商品"+"服务端口号："+serverPort;
                System.out.println(retMessage+"当前商品剩余："+(num+1-count)+"件。");
                // 模拟长业务
                try {TimeUnit.SECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

            }else{
                retMessage="商品已售罄！非常抱歉！";
                System.err.println(retMessage);
            }
        }finally {
            myRedisLockFromFactory.unlock();
        }
        return retMessage;
    }

在自定义分布式锁加入定时任务：

private void reNewExpire() {
        String lua_reNewExpire="if(redis.call('hexists',KEY[1],ARGC[1] ==1 ) then" +
                "                   return redis.call('expire',KEY[1],ARGV[2])" +
                "                   else" +
                "               return 0;" +
                "               end";
       new Timer().schedule(new TimerTask() {
           @Override
           public void run() {
               if(stringRedisTemplate.execute(new DefaultRedisScript<>(lua_reNewExpire, Boolean.class), Arrays.asList(key), value, String.valueOf(expireTime))){
                   reNewExpire();
               }
           }
       },(this.expireTime*1000) / 3);//每三分之一过期时长执行一次

    }

重写加锁流程：

 @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if(time == -1){
            String lua_lock="if(redis.call('exist',KEY[1],ARGV[1]) == 0 or redis.call('hexist',KEY[1],ARGV[1]) == 1) then" +
                    "            redis.call('hincrby',KEY[1],ARGV[1],1)" +
                    "            redis.call('expire',KEY[1],ARGV[2])" +
                    "            return 1" +
                    "        else" +
                    "            return 0" +
                    "        end";
            while(!stringRedisTemplate.execute(new DefaultRedisScript<>(lua_lock,Boolean.class), Arrays.asList(key),value,String.valueOf(expireTime))){
                TimeUnit.MILLISECONDS.sleep(50);
            }
            // 后台程序，自动续期
            reNewExpire();
            System.out.println("锁的名字："+key);
            return true;
        }
        return false;
    }

缺点：安全性不能提供保证，例如，当Redis服务器宕机。
改进：使用基于Redis官方提供的RedLock算法来实现多个实例下的分布式锁。例如基于Java的Redisson。

4.总结

使用Redis实现分布式锁是一种有效的方式来管理并发访问共享资源。Redis提供了原子性的操作，特别适合用于构建分布式锁。在这种锁的设计中，每个请求都尝试获取锁，只有一个请求成功，其他请求被阻塞。利用Redis的SETNX（SET if Not eXists）命令，可以确保锁的原子性，从而避免竞争条件。

这种分布式锁的优点包括快速响应、可靠性和简单性。但需要注意的是，为了避免死锁，锁应该具有超时机制，以确保即使持有锁的客户端崩溃，锁最终会被释放。此外，分布式锁的实现需要谨慎处理锁的释放，确保只有持有锁的客户端才能释放它。总之，Redis分布式锁是构建分布式系统中的重要工具，可用于解决并发访问共享资源时的竞争条件问题。
但是需要考虑更多的细节，一步一步改进。
在这里插入图片描述

来自宇宙的曹先生
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis解决方案：超买 超卖 （Redis队列pop原子性操作）
野蛮女孩的博客
07-06 1465
1、Redis是单进程单线程的网络模型，用的是epoll网络模型，网络模型都是单线程异步非阻塞处理网络请求2、Redis的单线程处理所有的客户端连接请求，命令读写请求。（有些任务比如rdb和aof等操作是fork子进程处理的，不会影响redis主线程处理客户端的命令）3、Redis提供的所有API操作，相对于服务端方面都是one by one执行的，命令是一个接着一个执行的，不存在并行执行的情况。
Redis分布式锁解决超卖问题
不更了，主打一个陪伴
06-28 525
Redis分布式锁解决超卖问题
用Redis实现超卖
最新发布
weixin_45946479的博客
03-26 316
使用 Redisson 的分布式锁可以确保在高并发环境下，只有一个线程能够获取锁并执行同步代码块，从而避免竞态条件和数据不一致的问题。用Redis实现超卖的总体思路是减少对数据库的访问，尽可能将数据缓存到Redis缓存中。接收到秒杀请求时，在Redis中进行预减库存，当Redis中的库存不足时，直接返回秒杀失败。服务端异步队列将请求出队，出队成功的请求可以生成秒杀订单，并返回秒杀订单详情。通过使用Redis缓存，可以有效避免超卖问题的发生，提高系统的性能和用户体验。将请求放入异步队列中，返回正在排队中。
Redis锁解决超卖问题
genggengxinhe1988的博客
07-17 1457
Redis锁解决超卖问题
【Redis】电商项目秒杀问题之超卖问题与一人一单问题
qq_61903414的博客
05-10 2766
在如双11等购物需求剧增的背景下，一个物品库存里有100件但是由于并发等问题可能会导致该物品被卖出超过100件。这就是超卖问题，他是由于库存量被高并发请求而产生的线程安全问题。
基于Redis（SETNX）实现分布式锁，案例：解决高并发下的订单超卖，秒杀
TianYu
05-04 7383
高并发的情况下订单超卖/秒杀问题 这里的问题就是在同一时间发过来了两个请求。这两个用户购买同一件数量的商品。线程之间没有互斥。也就是你运行你的。我运行我的。导致在线程1还未实际扣除库存的时候。线程2也获取到了和线程1相同的数量的商品。它两同时扣除库存。这样就出现了订单超卖的问题！！！ 解决订单超卖/秒杀的办法 分布式锁? 分布式锁就是在多个服务集群的模式下 每个服务下的线程可以做到互斥的效果 这就是分布式锁 并且分布式锁还要达到 高性能 高可见 高互斥 高可用 这样才叫分布式锁 SETNX的作
以超卖案例深入理解Redis分布式锁
黑马程序员官方博客
11-10 1337
本文介绍了超卖问题产生的原因：操作不具备原子性，同时提出了集中解决思路。synchronized锁，无法保证多实例下的线程安全setnx手动实现，坑很多、代码较为复杂redisson实现，能够保证多实例下线程安全，代码简单可靠。
PHP+Redis链表解决高并发下商品超卖问题(实现原理及步骤)
10-15
2. **分布式锁**：虽然Redis的链表操作是原子性的，但在高并发场景下，可以考虑使用分布式锁来进一步提高安全性，避免并发操作带来的问题。 3. **事务处理**：对于涉及多个Redis操作的场景，可以使用Redis事务...
PHP+Redis事务解决高并发下商品超卖问题(推荐)
10-15
2. **使用分布式锁**：如Redlock或单实例Redis锁，确保同一时间只有一个请求处理库存，避免并发请求间的相互干扰。 3. **库存预减策略**：在抢购开始前，预先减少库存，减少并发请求时的Redis操作。 4. **异步处理...
通过实例解析Java分布式锁三种实现方法
08-18
基于缓存实现分布式锁使用Redis等缓存系统来实现锁机制。主要使用三个命令：SETNX、expire和delete。 1. SETNX命令 SETNX命令用于设置一个key的值，如果key不存在，则设置成功，返回1；否则不做任何操作，返回0。 ...
Redis中的String类型及使用Redis解决订单秒杀超卖问题
01-19
本系列将和大家分享Redis分布式缓存，本章主要简单介绍下Redis中的String类型，以及如何使用Redis解决订单秒杀超卖问题。 Redis中5种数据结构之String类型：key-value的缓存，支持过期，value不超过512M。 Redis是...
分布式锁的实现1
08-03
在本文中，我们将深入探讨基于Redis实现的分布式锁及其关键特性。 首先，Redis提供了`SETNX`命令，用于在键不存在的情况下设置键值，这确保了分布式锁的互斥性。然而，仅仅使用`SETNX`还不足以防止死锁，因此通常会...
redis并发锁 thinkphp5_php在大并发下redis锁实现
weixin_28871475的博客
01-17 714
在现如今电商盛行的时期，会出现很多促销活动，最为常见的就是秒杀。在秒杀系统中最为常见的问题就是会出现超卖的情况，那么如何来杜绝超卖的情形了，在业务逻辑层面可以使用缓存以及加锁的手法来避免超卖的情形。现如今nosql已经非常流行和稳定了，在此我将通过redis和php来说明如何实现锁机制。当然我使用redis加锁并不是我的秒杀系统，而是最近做的一个项目有个用户提现，初期没有考虑到会有人恶意刷新接口，...
微服务Spring Boot 整合 Redis 分布式锁 Redission 实现优惠卷秒杀 一人一单
wanghuichen的博客
10-14 6003
Redis 首选 Java客户端 Redission，如何使用Redission 实现分布式锁？
Redis分布式锁——秒杀超卖
xiaowanziddd的博客
07-03 1674
分布式锁应用场景 秒杀环境下：订单服务从库存中心拿到库存数，如果库存总数大于0，则进行库存扣减，并创建订单 订单服务负责创建订单 库存服务负责扣减库存 模拟用户访问库存 多线程并发访问，出现超卖问题，线程不安全。没有保证原子性单体锁的分类 单体应用锁指的是只能在 一个JVM 进程内有效的锁。我们把这种锁叫做单体应用锁分布式锁核心逻辑 分布式锁的核心逻辑就是在多个服务中设置一个公共的资源，在公共资源中设置锁，供多个服务去同时抢夺锁资源，一旦其中一个线程抢夺成功，其他线程就进入自旋状态，不同的尝试访问获
redis并发锁 thinkphp5_php使用redis锁限制并发访问类示例(学习记录)
weixin_29191669的博客
02-11 455
RedisLock.class.php/*** Redis锁操作类* Date: 2016-06-30* Author: fdipzone* Ver: 1.0** Func:* public lock 获取锁* public unlock 释放锁* private connect 连接*/class RedisLock { // class startprivate $_config;pri...
redis并发锁 thinkphp5_thinkphp5 + redis 实现接口高并发限流
weixin_29596051的博客
02-11 1200
基于redis实现接口限流，主要使用Redis的一个模块：Redis-Cell话不多述直接上代码：先看下我项目目录: LeakyBucket实现类namespace app\common\server;class LeakyBucket{protected $key = null;protected $max_burst = null;protected $tokens = null;protec...
分布式锁1：5种方案解决商品超卖的方案的优缺点
健康平安的活着的专栏
10-02 856
在多线程高并发场景下，为了保证资源的线程安全问题，jdk为我们提供了synchronized关键字和ReentrantLock可重入锁，但是它们只能保证一个工程内的线程安全。在分布式集群、微服务、云原生横行的当下，jdk并没有给我们提供既有的解决方案。需要自己通过编写方案来解决，目前主流的实现有以下方式：基于mysql关系型实现基于redis非关系型数据实现基于zookeeper/etcd实现。
【解决案例】使用Redis解决秒杀过程中超卖问题
cheng__yu的博客
01-21 4986
最近打算写个专栏专门记录下遇到的一些案例解决，也算是记录一些成长的经验吧。 本篇文章背景是在完善商城秒杀系统时发现秒杀时会出现超卖问题，然后在参考一系列解决方案后决定采用Redis记录库存数目来解决，但是在其中还是出现了一些问题。 1. 初解 出现问题的代码块： //获取库存数目 int stock = Integer.parseInt(redisTemplate.opsForValue().get("stock")); //库存数目大于零则减库存 if(stock > 0){ int fi
redis分布式锁解决超买超卖问题的详细流程
07-14
Redis分布式锁可以用来解决超买超卖问题，下面是详细的流程： 1. 创建一个唯一的标识符（例如订单号）作为锁的名称。 2. 在Redis中尝试获取锁，可以使用SETNX命令（如果键不存在则设置成功）或者SET命令（带有NX参数）来实现。锁的值可以是一个随机生成的唯一字符串，用于标识持有该锁的客户端。 3. 如果获取锁成功，执行业务逻辑，比如减少库存或者增加订单数量。 4. 在业务逻辑执行完毕后，释放锁，可以使用DEL命令来删除对应的键。 5. 如果获取锁失败，则等待一段时间后重新尝试获取锁，可以使用SLEEP命令来进行等待。 需要注意的是，在执行业务逻辑期间，应该设置一个合理的锁的过期时间，以防止持有锁的客户端出现异常导致锁无法释放。另外，为了避免死锁情况的发生，可以为每个客户端设置一个唯一的标识符，并且只允许持有锁的客户端释放该锁。 通过使用Redis分布式锁，可以保证在高并发场景下只有一个客户端可以执行关键业务逻辑，从而避免了超买或超卖的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值