Redis---------实现商品秒杀业务，包括唯一ID，超卖问题，分布式锁

发布于：2024-05-05 ⋅ 阅读:(33) ⋅ 点赞:(0)

 订单ID必须是唯一

59e1602b09834e0aadaa9602bbc8a20f.png

 唯一ID构成：

e0304f55e1f348838355b3126378a22d.png

代码生成唯一ID：


import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

//基于redis自增长的生成策略
@Component
public class RedisUUID {
    //起始时间时间秒数
    private static final long BEGIN_TIMESTAMP=1640995200L;
    
    //使用Redis自增策略
    private StringRedisTemplate stringRedisTemplate;

    public RedisUUID(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    //参数是业务的类型
    public long nextid(String keyType){
        //1，生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowsecend = now.toEpochSecond(ZoneOffset.UTC);
        //当前时间的秒数减去起始时间的秒数得到时间戳
        long nowtime_stamp = nowsecend - BEGIN_TIMESTAMP;

        //2，生成序列号
        String nowdate = now.format(DateTimeFormatter.ofPattern("yyyy:mm:dd"));//使得每天都会生成新的一轮ID
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyType + ":" + nowdate);

        //3，拼接返回
        return nowtime_stamp << 32 | count;
    }
}

827128d84da44b4793c030401783ed74.png

 

商品下单操作

业务逻辑：

7700ca73332d48708595361f1ae99dc3.jpg

 思路:主要是要了解以及掌握整个业务的流程:①先看商品是不是在秒杀的时间范围内②然后还要去看库存中是否还有该商品③如果有的话就扣减库存④然后就会生成订单，订单ID为唯一ID⑤把订单写入数据库中，再返回数据给前端

代码实现：

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Autowired
    private ISeckillVoucherService iSeckillVoucherService;

    @Autowired
    private RedisUUID redisUUID;

    @Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {

        //1,查询商品的信息
        SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);

        //2，看是否在秒杀时间范围内
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            return Result.fail("尚未开始！");
        }
        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            return Result.fail("已经结束啦！");
        }

        //3，再看库存是否还有
        if (voucher.getStock()<1) {
            return Result.fail("库存不足!");
        }

        //4，如果有就减扣库存
        boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).update();
        if (!sucess) {
            return Result.fail("库存不足！");
        }

        //5，然后就创建订单信息
        VoucherOrder voucherOrder = new VoucherOrder();
            //5.1，订单id----id生成器
            long order = redisUUID.nextid("order");
            voucherOrder.setVoucherId(order);
            //5.2，用户id
            Long id = UserHolder.getUser().getId();
            voucherOrder.setUserId(id);
            //5.3，商品id
            voucherOrder.setVoucherId(voucherId);

        //6，保存进数据库
        save(voucherOrder);

        //7，返回数据
        return Result.ok(order);
    }
}

 

库存超卖问题

先看看什么是库存超卖问题:

正常情况:

ec6c0f2b42804805a77a24f6e75ce430.jpg

 但是涉及到高并发的时候一定会出问题:

b46184b741a443fdbfa8f540833db7cf.jpg

所以我们要想办法去解决这个问题，锁！！！

ee298fbbb6684e16bc4411dcc7c90c40.jpg

 悲观锁认为一定发生并发问题，所以每一次操作都会加锁，是线程串行进行，不会出现并发问题，但是这样的话就导致性能降低，所以我们使用乐观锁，乐观锁是先让你操作，等你要修改数据库的时候再判断与你查到的数据是否是一样，如果是一样的才可以修改，否则不可以减库存。

乐观锁的两种实现判断法：

第一种:版本号法，就是通过查询两次版本号来判断是否被修改过库存

ac6f979be91d4cba9c36fff6f96e61a8.jpg

第二种:CAS法，是在版本号法上做的改进方法，既然要判断两次版本是否相同，为啥不判断库存量是否相同呢，所以CSA法就是去判断前后两次查询到的库存量是否一样，如果一样就可以改

c859dfee73f44fd9844699936966ab0c.jpg

用乐观锁CAS法来解决超卖问题：

//4，如果有就减扣库存
        boolean sucess = iSeckillVoucherService.update()
                    .setSql("stock = stock - 1")
                    .eq("voucher_id", voucherId)
                    .eq("stock",voucher.getStock())
                    .update();
        if (!sucess) {
            return Result.fail("库存不足！");
        }

但是这样任然还不能解决超卖问题，因为如果两个线程同时来查到100,线程1做完修改还剩99,线程2查到不是100就会不执行修改，这样也会有问题，所以又要进行改进策略

 //4，如果有就减扣库存
        boolean sucess = iSeckillVoucherService.update()
                    .setSql("stock = stock - 1")
                    .eq("voucher_id", voucherId)
                    .gt("stock",0)
                    .update();
        if (!sucess) {
            return Result.fail("库存不足！");
        }

一人一单问题

 使用悲观锁处理单体服务下的多线程问题：

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Autowired
    private ISeckillVoucherService iSeckillVoucherService;

    @Autowired
    private RedisUUID redisUUID;

    @Override

    public Result seckillVoucher(Long voucherId) {

        //1,查询商品的信息
        SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);

        //2，看是否在秒杀时间范围内
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            return Result.fail("尚未开始！");
        }
        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            return Result.fail("已经结束啦！");
        }

        //3，再看库存是否还有
        if (voucher.getStock()<1) {
            return Result.fail("库存不足!");
        }

        //实现单体服务下的一人一单的多线程安全问题
        
        Long id = UserHolder.getUser().getId();
        //先获取锁，再提交事务，保证线程安全
        synchronized (id.toString().intern()){
            //获得Spring的代理对象(事务)
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
    }

    @Transactional
    public Result createVoucherOrder(Long voucherId) {
        //一人一单问题
        Long id = UserHolder.getUser().getId();
        Integer count = query().eq("user_id", id).eq("voucher_id", voucherId).count();

        if(count > 0){
            return Result.fail("你已经购买过！");
        }

        //4，如果有就减扣库存
        boolean sucess = iSeckillVoucherService.update()
                    .setSql("stock = stock - 1")
                    .eq("voucher_id", voucherId)
                    .gt("stock",0)
                    .update();
        if (!sucess) {
            return Result.fail("库存不足！");
        }

        //5，然后就创建订单信息
        VoucherOrder voucherOrder = new VoucherOrder();
        //5.1，订单id----id生成器
        long order = redisUUID.nextid("order");
        voucherOrder.setVoucherId(order);

        //5.2，用户id
        voucherOrder.setUserId(id);

        //5.3，商品id
        voucherOrder.setVoucherId(voucherId);

        //6，保存进数据库
        save(voucherOrder);

        //7，返回数据
        return Result.ok(order);
    }
}

 添加依赖：

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

 在启动类上添加：

@EnableAspectJAutoProxy(exposeProxy = true)

分布式集群模式下的多线程问题：

当我们是处理分布式集群模式下，两个JVM不是共用一把锁，导致每个JVM都有自己的锁导致我们之前的锁锁不住，每个JVM都有一个线程会获得锁。

 

 分布式锁：满足分布式系统或者集群模式下多进程可见并且互斥的锁

 

 

 基于Redis实现分布式锁：

创建锁对象：
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;


public class SimpleRedisLock implements ILock{

    private String name;
    private StringRedisTemplate stringRedisTemplate;
    private static final  String KEY_PREFXY="lock:";

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }


    @Override
    public boolean trylock(long timeoutSec) {
        //获取线程ID作为标识
        long ThreadId = Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFXY + name, ThreadId + "", timeoutSec, TimeUnit.MINUTES);
        //避免空指针
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        stringRedisTemplate.delete(KEY_PREFXY + name);
    }
}
代码实现Redis分布式锁的应用：

①先创建锁的对象，然后先是去获取锁②没有获取到锁就直接返回错误③获取到锁就可以进行对数据库的操作④操作完之后进行释放锁

Long id = UserHolder.getUser().getId();
        //创建锁对象
        SimpleRedisLock simpleRedisLock = new SimpleRedisLock("order" + id, stringRedisTemplate);

        //获取锁
        boolean trylock = simpleRedisLock.trylock(1200);
        //判断是否获得锁成功
        if (!trylock) {
            //获取锁失败
            return Result.fail("不允许重复下单！");
        }

        //获得Spring的代理对象(事务)
        try {
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        } finally {
            //释放锁
            simpleRedisLock.unlock();
        }

 但是就上面的处理还不够严谨，因为如果一个线程发生阻塞的话，其他线程可能会获得锁并且释放锁，导致锁误删问题，

解决锁误删问题：
import cn.hutool.core.lang.UUID;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock{

    private String name;
    private StringRedisTemplate stringRedisTemplate;
    private static final  String KEY_PREFXY="lock:";
    
    //得到一个唯一锁的标识
    private static final  String ID_PREFXY= UUID.randomUUID(true)+"-";

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }


    @Override
    public boolean trylock(long timeoutSec) {
        //获取线程标识
        String ThreadId = ID_PREFXY+Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFXY + name, ThreadId, timeoutSec, TimeUnit.MINUTES);
        //避免空指针
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {

        //获取线程标识
        String ThreadId = ID_PREFXY+Thread.currentThread().getId();
        //判断要来修改的进程跟锁的标识是否一致
        String s = stringRedisTemplate.opsForValue().get(KEY_PREFXY + name);

        if(ThreadId.equals(s)){
            //释放锁
            stringRedisTemplate.delete(KEY_PREFXY + name);
        }
    }
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布