优惠卷秒杀系统设计全局唯一ID生成，秒杀下单，分析解决库存超卖(乐观锁)实现一人一单秒杀业务(对用户id加锁)集群模式下并发问题

Posted 2022-09-16 Perceus

(目录)

---

1. 优惠卷秒杀

---

优惠卷秒杀

1. 全局唯一ID

每个店铺都可以发布优惠券：

当用户抢购时，就会生成订单并保存到tb_voucher_order这张表中，而订单表如果使用数据库自增ID就存在一些问题：

---

场景分析：

场景分析二：

全局ID生成器，是一种在分布式系统下用来生成全局唯一ID的工具，一般要满足下列特性：

为了增加ID的安全性，我们可以不直接使用Redis自增的数值，而是拼接一些其它信息：

ID的组成部分：

---

2. Redis实现全局唯一Id

@Component
public class RedisIdWorker 
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号的位数
     */
    private static final int COUNT_BITS = 32;

    private StringRedisTemplate stringRedisTemplate;

    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) 
        this.stringRedisTemplate = stringRedisTemplate;
    

    public long nextId(String keyPrefix) 
        // 1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        // 2.生成序列号
        // 2.1.获取当前日期，精确到天
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 2.2.自增长
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        // 3.拼接并返回
        return timestamp << COUNT_BITS | count;
    

---

测试类

知识小贴士：关于countdownlatch

CountDownLatch 中有两个最重要的方法

await 方法 是阻塞方法，我们担心分线程没有执行完时，main线程就先执行，所以使用await可以让main线程阻塞，那么什么时候main线程不再阻塞呢？

    private ExecutorService pool = Executors.newFixedThreadPool(500);

    @Test
    void testIdWorker() throws InterruptedException 
        CountDownLatch latch = new CountDownLatch(300);

        Runnable task = () -> 
            for (int i = 0; i < 100; i++) 
                long id = redisIdWorker.nextId("order");
                System.out.println("id = " + id);
            
            latch.countDown();
        ;
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 300; i++) 
            pool.submit(task);
        
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - begin));
    

---

3. 添加优惠卷

数据库设计：

平价卷由于优惠力度并不是很大，所以是可以任意领取

而代金券由于优惠力度大，所以像第二种卷，就得限制数量，从表结构上也能看出，特价卷除了具有优惠卷的基本信息以外，还具有库存，抢购时间，结束时间等等字段

@PostMapping
public Result addVoucher(@RequestBody Voucher voucher) 
    voucherService.save(voucher);
    return Result.ok(voucher.getId());

新增秒杀卷代码：

@PostMapping("seckill")
public Result addSeckillVoucher(@RequestBody Voucher voucher) 
    voucherService.addSeckillVoucher(voucher);
    return Result.ok(voucher.getId());

VoucherServiceImpl

@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) 
    // 保存优惠券
    save(voucher);
    // 保存秒杀信息
    SeckillVoucher seckillVoucher = new SeckillVoucher();
    seckillVoucher.setVoucherId(voucher.getId());
    seckillVoucher.setStock(voucher.getStock());
    seckillVoucher.setBeginTime(voucher.getBeginTime());
    seckillVoucher.setEndTime(voucher.getEndTime());
    seckillVoucherService.save(seckillVoucher);
    // 保存秒杀库存到Redis中
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());

---

4. 实现秒杀下单

下单核心思路：当我们点击抢购时，会触发右侧的请求，我们只需要编写对应的controller即可

秒杀下单应该思考的内容：

下单时需要判断两点：

下单核心逻辑分析：

VoucherOrderServiceImpl类： 实现

@Override
public Result seckillVoucher(Long voucherId) 
    // 1.查询优惠券
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    // 2.判断秒杀是否开始
    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) 
        // 尚未开始
        return Result.fail("秒杀尚未开始！");
    
    // 3.判断秒杀是否已经结束
    if (voucher.getEndTime().isBefore(LocalDateTime.now())) 
        // 尚未开始
        return Result.fail("秒杀已经结束！");
    
    // 4.判断库存是否充足
    if (voucher.getStock() < 1) 
        // 库存不足
        return Result.fail("库存不足！");
    
    //5，扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId).update();
    if (!success) 
        //扣减库存
        return Result.fail("库存不足！");
    
    //6.创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    // 6.1.订单id
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);
    // 6.2.用户id
    Long userId = UserHolder.getUser().getId();
    voucherOrder.setUserId(userId);
    // 6.3.代金券id
    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);

    return Result.ok(orderId);

---

5. 库存超卖 问题分析

有关超卖问题分析：在我们原有代码中是这么写的

 if (voucher.getStock() < 1) 
        // 库存不足
        return Result.fail("库存不足！");
    
    //5，扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId).update();
    if (!success) 
        //扣减库存
        return Result.fail("库存不足！");
    

假设：

---

超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁：

而对于加锁，我们通常有两种解决方案：见下图：

悲观锁：

乐观锁：

其中do while 是为了在操作失败时，再次进行自旋操作，即把之前的逻辑再操作一次。

int var5;
do 
    var5 = this.getIntVolatile(var1, var2);
 while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

return var5;

---

使用的方式：

课程中的使用方式是没有像cas一样带自旋的操作，也没有对version的版本号+1 ，他的操作逻辑是在操作时，对版本号进行+1 操作，然后要求version 如果是1 的情况下，才能操作，那么第一个线程在操作后，数据库中的version变成了2，但是他自己满足version=1 ，所以没有问题，此时线程2执行，线程2 最后也需要加上条件version =1 ，但是现在由于线程1已经操作过了，所以线程2，操作时就不满足version=1 的条件了，所以线程2无法执行成功

---

6. 乐观锁 解决超卖问题

修改代码方案一、

boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1") //set stock = stock -1
            .eq( her.getStock()).update(); //where id = ？ and stock = ?

以上逻辑的核心含义是：

---

修改代码方案二、

之前的方式要修改前后都保持一致，但是这样我们分析过，成功的概率太低，所以我们的乐观锁需要变一下，改成 stock大于0 即可

boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId).update().gt("stock",0); //where id = ? and stock > 0

---

知识小扩展：

---

7. 优惠券秒杀 - 一人一单

需求：

现在的问题在于：

具体操作逻辑如下：

VoucherOrderServiceImpl

@Override
public Result seckillVoucher(Long voucherId) 
    // 1.查询优惠券
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    // 2.判断秒杀是否开始
    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) 
        // 尚未开始
        return Result.fail("秒杀尚未开始！");
    
    // 3.判断秒杀是否已经结束
    if (voucher.getEndTime().isBefore(LocalDateTime.now())) 
        // 尚未开始
        return Result.fail("秒杀已经结束！");
    
    // 4.判断库存是否充足
    if (voucher.getStock() < 1) 
        // 库存不足
        return Result.fail("库存不足！");
    
		 // 5.一人一单逻辑
        // 5.1.用户id
        Long userId = UserHolder.getUser().getId();
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        // 5.2.判断是否存在
        if (count > 0) 
            // 用户已经购买过了
            return Result.fail("用户已经购买过一次！");
        

		//6，扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock= stock -1") //set stock = stock -1
                .eq("voucher_id", voucherId).gt("stock",0).update(); //where id = ？ and stock > 0
        // .eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update(); //where id = ？ and stock = ?
    if (!success) 
        //扣减库存
        return Result.fail("库存不足！");
    
    //7.创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    // 7.1.订单id
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);

    voucherOrder.setUserId(userId);
    // 7.3.代金券id
    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);

    return Result.ok(orderId);

存在问题： 多个线程查到 0 直接进行下面下单操作

---

注意：

在这里提到了非常多的问题，我们需要慢慢的来思考

@Transactional
public synchronized Result createVoucherOrder(Long voucherId) 

	Long userId = UserHolder.getUser().getId();
         // 5.1.查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        // 5.2.判断是否存在
        if (count > 0) 
            // 用户已经购买过了
            return Result.fail("用户已经购买过一次！");
        

        // 6.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                .update();
        if (!success) 
            // 扣减失败
            return Result.fail("库存不足！");
        

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 7.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 7.2.用户id
        voucherOrder.setUserId(userId);
        // 7.3.代金券id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        // 7.返回订单id
        return Result.ok(orderId);

但是这样添加锁，锁的粒度太粗了，性能太差，在使用锁过程中，控制锁粒度 是一个非常重要的事情，因为如果锁的粒度太大，会导致每个线程进来都会锁住，所以我们需要去控制锁的粒度，以下这段代码需要修改为：对不同用户id加锁

@Transactional
public  Result createVoucherOrder(Long voucherId) 
	Long userId = UserHolder.getUser().getId();
	synchronized(userId.toString().intern())
         // 5.1.查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        // 5.2.判断是否存在
        if (count > 0) 
            // 用户已经购买过了
            return Result.fail("用户已经购买过一次！");
        

        // 6.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                .update();
        if (!success) 
            // 扣减失败
            return Result.fail("库存不足！");
        

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 7.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 7.2.用户id
        voucherOrder.setUserId(userId);
        // 7.3.代金券id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        // 7.返回订单id
        return Result.ok(orderId);
    

但是以上代码还是存在问题：

在seckillVoucher 方法中，添加以下逻辑，这样就能保证事务的特性，同时也控制了锁的粒度

---

但是以上做法依然有问题：事务失效

        synchronized (userId.toString().intern()) 
            // 获取 代理对象(事务)
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        

---

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

@EnableAspectJAutoProxy(exposeProxy = true)
@SpringBootApplication
public class HmDianPingApplication 

    public static void main(String[] args) 
        SpringApplication.run(HmDianPingApplication.class, args);
    

效果：

---

8. 集群环境下的并发问题

通过加锁可以解决在单机情况下的一人一单安全问题，但是在集群模式下就不行了。

upstream backend 
	server 127.0.0.1:8081 max_fails=5 fail_timeout=10s weight=1;
	server 127.0.0.1:8082 max_fails=5 fail_timeout=10s weight=1;

---

发送两次请求：

---

集群模式下有关锁失效原因分析

---