【Redis】实战篇：优惠卷秒杀 (库存超卖问题、一人一单问题）

笔记参考：黑马程序员Redis入门到实战教程

3.1 全局唯一ID

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

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

• id的规律性太明显
• 受单表数据量的限制

场景分析：如果我们的id具有太明显的规则，用户或者说商业对手很容易猜测出来我们的一些敏感信息，比如商城在一天时间内，卖出了多少单，这明显不合适。

场景分析二：随着我们商城规模越来越大，mysql的单表的容量不宜超过500W，数据量过大之后，我们要进行拆库拆表，但拆分表了之后，他们从逻辑上讲他们是同一张表，所以他们的id是不能一样的， 于是乎我们需要保证id的唯一性。

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

• 唯一性：订单id必须唯一
• 高可用：必须保证无论何时使用的时候都能生成正确的id
• 高性能：保证生成id的速度足够快
• 递增性：保证整体的一个逐渐变大的特性，可以有利于数据库创建索引，提高查询的速度
• 安全性：id规律不能太明显，让人一眼就看出。

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

ID的组成部分：

符号位：1bit，永远为0,代表正数

时间戳：31bit，以秒为单位，可以使用69年

序列号：32bit，秒内的计数器，支持每秒产生2^32个不同ID

3.2 -Redis实现全局唯一Id

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

@Component
public class RedisIdWorker {

    // 开始时间戳
    private static final long BEGID_TIMESTAMP = 1640995200L;

    @Resource
    private StringRedisTemplate stringRedisTemplate;


    // 序列号的位数
    private static final int COUNT_BITS = 32;

    /**
     * 不同的业务会有不同的前缀
     *
     * @param keyPrefix
     * @return
     */
    public long nextId(String keyPrefix) {
        //1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timeStamp = nowSecond - BEGID_TIMESTAMP;
        //2.生成序列号
        // 以天为单位，这里假设一天不会超过限度
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
        //3.拼接并返回
        return timeStamp << COUNT_BITS | count;
    }

//    public static void main(String[] args) {
//        // 初始时间
//        LocalDateTime time = LocalDateTime.of(2022, 1, 1, 0, 0, 0);
//        long l = time.toEpochSecond(ZoneOffset.UTC);
//        System.out.println(l);
//    }
}

测试类：

countdownlatch有关知识：

countdownlatch名为信号枪：主要的作用是同步协调在多线程的等待与唤醒问题

我们如果没有CountDownLatch ，那么由于程序是异步的，当异步程序没有执行完时，主线程就已经执行完了，然后我们期望的是分线程全部走完之后，主线程再走，所以我们此时需要使用到CountDownLatch

CountDownLatch 中有两个最重要的方法

1、countDown

2、await

await 方法 是阻塞方法，我们担心分线程没有执行完时，main线程就先执行，所以使用await可以让main线程阻塞，那么什么时候main线程不再阻塞呢？当CountDownLatch 内部维护的 变量变为0时，就不再阻塞，直接放行，那么什么时候CountDownLatch 维护的变量变为0 呢，我们只需要调用一次countDown ，内部变量就减少1，我们让分线程和变量绑定， 执行完一个分线程就减少一个变量，当分线程全部走完，CountDownLatch 维护的变量就是0，此时await就不再阻塞，统计出来的时间也就是所有分线程执行完后的时间。

@Test
void testIdWorker1() throws InterruptedException {
    // 创建值为300计数器
    CountDownLatch latch = new CountDownLatch(300);
    int a = 1;
    Runnable task = () -> {
        for (int i = 0; i < 100; i++) {
            long id = redisIdWorker.nextId("order");
            System.out.println("id = " + id);
        }
        // 计数器 - 1
        latch.countDown();
    };
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 300; i++) {
        es.submit(task);
    }
    // 将main线程阻塞，直到计数器为0是才唤醒
    latch.await();
    long end = System.currentTimeMillis();
    System.out.println("time = " + (end - begin));
}

小结

全局唯一ID生成策略：

• UUID
• redis自增
• 雪花算法
• 数据库自增

Redis自增ID策略：

• 每天一个key，方便统计订单量
• ID构造是：时间戳 + 计数器

3.3 添加优惠卷

每个店铺都可以发布优惠券，分为平价券和特价券。平价券可以任意购买，而特价券需要秒杀抢购：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ouksrg4c-1667139730318)(https://xiaoxin18.oss-cn-hangzhou.aliyuncs.com/2022/image-20221029200958200.png)]

tb_voucher：优惠券的基本信息，优惠金额、使用规则等
tb_seckill_voucher：优惠券的库存、开始抢购时间，结束抢购时间。特价优惠券才需要填写这些信息

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

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

tb_voucher表结构

tb_seckill_voucher表结构

通过表结构我们可以发现，秒杀卷中有平价卷没有的字段，为了节约空间和提高性能，我们可以放在两张表里。

**新增普通卷代码： **VoucherController

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

新增秒杀卷代码：

VoucherController

@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);
}

新增秒杀券接口中，我们发现传入是平价券类，唉，这样不就是有问题了吗，那些平价券没有的字段怎么办？

其实人家已经帮我们想好了这个问题，这个类其实把秒杀券特有的字段加上了，并且用了TableField声明那些字段在表中不存在，这样就解决了这个问题。

测试：

我们用Postman来测试一下

注意，这里的结束时间要比你当前时间大，不然前端会判断这个券已过期不显示这张券。

{
    "shopId":1,
    "title":"100元代金券",
    "subTitle":"周一至周日均可使用",
    "rules":"全场通用\\n无需预约\\n可无限叠加\\不兑现、不找零\\n仅限堂食",
    "payValue":8000,
    "actualValue":10000,
    "type":1,
    "stock":100,
    "beginTime": "2022-10-26T10:00:00",
    "endTime":"2022-12-26T14:00:00"
}

测试结果：

3.4 实现秒杀下单

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

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

下单时需要判断两点：

• 秒杀是否开始或结束，如果尚未开始或已经结束则无法下单
• 库存是否充足，不足则无法下单

下单核心逻辑分析：

当用户开始进行下单，我们应当去查询优惠卷信息，查询到优惠卷信息，判断是否满足秒杀条件

比如时间是否充足，如果时间充足，则进一步判断库存是否足够，如果两者都满足，则扣减库存，创建订单，然后返回订单id，如果有一个条件不满足则直接结束。

VoucherOrderServiceImpl

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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    /**
     * 这里用到了用到了修改和保存，以防万一我们加上事务
     *
     * @param voucherId
     * @return
     */
    @Override
    @Transactional
    public Result seckillVocher(Long voucherId) {
        // 1 查询优惠卷信息
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 2. 判断秒杀是否开始
        LocalDateTime beginTime = seckillVoucher.getBeginTime();
        if (beginTime.isAfter(LocalDateTime.now())) {
            return Result.fail("活动未开始");
        }
        // 3.判断秒杀是否结束
        LocalDateTime endTime = seckillVoucher.getEndTime();
        if (endTime.isBefore(LocalDateTime.now())) {
            return Result.fail("活动已结束");
        }
        // 4.判断库存是否充足
        Integer stock = seckillVoucher.getStock();
        if (seckillVoucher.getStock() < 1) {
            return Result.fail("库存不足!");
        }

        // 5.扣减库存
        boolean ok = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
                .update();
        if (!ok) {
            return Result.fail("库存不足!");
        }

        // 6.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 用户id
        voucherOrder.setUserId(UserHolder.getUser().getId());
        // 秒杀券id
        voucherOrder.setVoucherId(voucherId);
        // 写入数据库
        boolean save = save(voucherOrder);
        // 7.返回结果
        return Result.ok(orderId);
    }
}

3.5 库存超卖问题分析

我们现在来模拟一下高并发的情景：

用Jemter发送200个请求，然后到数据库中会发现票数变成了负数，这是怎么回事呢？

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

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("库存不足！");
}

假设线程1过来查询库存，判断出来库存大于1，正准备去扣减库存，但是还没有来得及去扣减，此时线程2过来，线程2也去查询库存，发现这个数量一定也大于1，那么这两个线程都会去扣减库存，最终多个线程相当于一起去扣减库存，此时就会出现库存的超卖问题。

超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁：而对于加锁，我们通常有两种解决方案：见下图：

悲观锁：

悲观锁可以实现对于数据的串行化执行，比如syn，和lock都是悲观锁的代表，同时，悲观锁中又可以再细分为公平锁，非公平锁，可重入锁，等等

乐观锁：

乐观锁：会有一个版本号，每次操作数据前会获取到它版本号，如果版本号等于之前获取到的版本号，就执行操作并 让版本号+1，如果不等于，表示数据已经被修改了，就不会执行操作。

关键是判断之前查询到的数据是否有被修改过。

3.6 乐观锁解决超卖问题

修改代码方案一、

VoucherOrderServiceImpl 在扣减库存时，改为：

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

以上逻辑的核心含义是：这里我们用库存来代替版本号，只要我扣减库存时的库存和之前我查询到的库存是一样的，就意味着没有人在中间修改过库存，那么此时就是安全的。

上面这种方法教CAS法（比较并交换）

但是以上这种方式通过测试发现会有很多失败的情况，失败的原因在于：在使用乐观锁过程中假设100个线程同时都拿到了100的库存，然后大家一起去进行扣减，但是100个人中只有1个人能扣减成功，其他的人在处理时，他们在扣减时，库存已经被修改过了，所以此时其他线程都会失败

再次执行高并发操作，发现一百张票只卖了20张。这也太离谱了吧。

修改代码方案二、

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

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

通过结果我们发现完美解决了这个问题

小结

超卖这样的线程安全问题，解决方案有哪些？

• 悲观锁：添加同步锁，让线程串行执行
  • 优点：简单粗暴
  • 缺点：性能一般
• 乐观锁：不加锁，在更新时判断是否有其他线程在修改
  • 优点：性能好
  • 缺点：存在成功率低的问题

3.7 优惠券秒杀-一人一单

需求：修改秒杀业务，要求同一个优惠券，一个用户只能下一单

现在的问题在于：

优惠卷是为了引流，但是目前的情况是，一个人可以无限制的抢这个优惠卷，所以我们应当增加一层逻辑，让一个用户只能下一个单，而不是让一个用户下多个单

具体操作逻辑如下：比如时间是否充足，如果时间充足，则进一步判断库存是否足够，然后再根据优惠卷id和用户id查询是否已经下过这个订单，如果下过这个订单，则不再下单，否则进行下单

修改代码

**VoucherOrderServiceImpl **

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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    /**
     * 这里用到了用到了修改和保存，以防万一我们加上事务
     *
     * @param voucherId
     * @return
     */
    @Override
    @Transactional
    public Result seckillVocher(Long voucherId) {
        // 1 查询优惠卷信息
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 2. 判断秒杀是否开始
        LocalDateTime beginTime = seckillVoucher.getBeginTime();
        if (beginTime.isAfter(LocalDateTime.now())) {
            return Result.fail("活动未开始");
        }
        // 3.判断秒杀是否结束
        LocalDateTime endTime = seckillVoucher.getEndTime();
        if (endTime.isBefore(LocalDateTime.now())) {
            return Result.fail("活动已结束");
        }
        // 4.判断库存是否充足
        Integer stock = seckillVoucher.getStock();
        if (seckillVoucher.getStock() < 1) {
            return Result.fail("库存不足!");
        }
        Long userId = UserHolder.getUser().getId();
        // 5.一人一单逻辑
        int count = query().eq("voucher_id", voucherId)
            .eq("user_id", userId).count();
        // 判断该用户是否购买过
        if (count > 0) {
            return Result.fail("用户已经购买过一次");
        }

        // 6.扣减库存
        boolean ok = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId)
            .gt("stock", 0)
            .update();
        if (!ok) {
            return Result.fail("库存不足!");
        }

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 用户id
        voucherOrder.setUserId(userId);
        // 秒杀券id
        voucherOrder.setVoucherId(voucherId);
        // 写入数据库
        boolean save = save(voucherOrder);
        // 8.返回结果
        return Result.ok(orderId);
    }
}

我们再来模拟一下高并发场景，发现一个用户买了十张票，现在的问题还是和之前一样，并发过来，查询数据库，都不存在订单，所以我们还是需要加锁，但是乐观锁比较适合更新数据，而现在是插入数据，所以我们需要使用悲观锁操作

**注意：**在这里提到了非常多的问题，我们需要慢慢的来思考，首先我们的初始方案是封装了一个createVoucherOrder方法，同时为了确保他线程安全，在方法上添加了一把synchronized 锁

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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    /**
     * 这里用到了用到了修改和保存，以防万一我们加上事务
     *
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVocher(Long voucherId) {
        // 1 查询优惠卷信息
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 2. 判断秒杀是否开始
        LocalDateTime beginTime = seckillVoucher.getBeginTime();
        if (beginTime.isAfter(LocalDateTime.now())) {
            return Result.fail("活动未开始");
        }
        // 3.判断秒杀是否结束
        LocalDateTime endTime = seckillVoucher.getEndTime();
        if (endTime.isBefore(LocalDateTime.now())) {
            return Result.fail("活动已结束");
        }
        // 4.判断库存是否充足
        Integer stock = seckillVoucher.getStock();
        if (seckillVoucher.getStock() < 1) {
            return Result.fail("库存不足!");
        }
        // 8.返回结果
        return createVoucherOrder(voucherId);
    }

    // 此时的同步锁是this,也就是说任何用户进来使用的是同一把锁
    @Transactional
    public synchronized Result createVoucherOrder(Long voucherId) {
        Long userId = UserHolder.getUser().getId();
        // 5.一人一单逻辑
        int count = query().eq("voucher_id", voucherId)
                .eq("user_id", userId).count();
        // 判断该用户是否购买过
        if (count > 0) {
            return Result.fail("用户已经购买过一次");
        }

        // 6.扣减库存
        boolean ok = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
                .gt("stock", 0)
                .update();
        if (!ok) {
            return Result.fail("库存不足!");
        }

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 用户id
        voucherOrder.setUserId(userId);
        // 秒杀券id
        voucherOrder.setVoucherId(voucherId);
        // 写入数据库
        boolean save = save(voucherOrder);
        return Result.ok(orderId);
    }
}

但是这样添加锁，锁的粒度太粗了，在使用锁过程中，控制锁粒度 是一个非常重要的事情，因为如果锁的粒度太大，会导致每个线程进来都会锁住，所以我们需要去控制锁的粒度，以下这段代码需要修改为：
intern() 这个方法是从常量池中拿到数据，如果我们直接使用userId.toString() 他拿到的对象实际上是不同的对象，new出来的对象，我们使用锁必须保证锁必须是同一把，所以我们需要使用intern()方法

// 此时的同步锁是this,也就是说任何用户进来使用的是同一把锁
@Transactional
public Result createVoucherOrder(Long voucherId) {
    Long userId = UserHolder.getUser().getId();
    // 锁的是用户
    synchronized (userId.toString().intern()) {
        // 5.一人一单逻辑
        int count = query().eq("voucher_id", voucherId)
            .eq("user_id", userId).count();
        // 判断该用户是否购买过
        if (count > 0) {
            return Result.fail("用户已经购买过一次");
        }

        // 6.扣减库存
        boolean ok = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId)
            .gt("stock", 0)
            .update();
        if (!ok) {
            return Result.fail("库存不足!");
        }

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 用户id
        voucherOrder.setUserId(userId);
        // 秒杀券id
        voucherOrder.setVoucherId(voucherId);
        // 写入数据库
        boolean save = save(voucherOrder);
        return Result.ok(orderId);
    }
}

但是以上代码还是存在问题，问题的原因在于当前方法被spring的事务控制，如果你在方法内部加锁，可能会导致当前方法事务还没有提交，但是锁已经释放了，用户会再次进入这个方法里，这样也会导致问题，所以我们选择将当前方法整体包裹起来，确保事务不会出现问题：如下：

但是以上做法依然有问题，因为你调用的方法，其实是this.的方式调用的，事务想要生效，还得利用代理来生效，所以这个地方，我们需要获得原始的事务对象， 来操作事务

添加依赖

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

暴露代理对象

@MapperScan("com.hmdp.mapper")
@SpringBootApplication
// 暴露代理对象
@EnableAspectJAutoProxy(exposeProxy = true)
public class HmDianPingApplication {

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

}

我们再来测试一下，这个问题完美解决了

3.8 集群环境下的并发问题

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

1、我们将服务启动两份，端口分别为8081和8082：

2、然后修改nginx的conf目录下的nginx.conf文件，配置反向代理和负载均衡：

这样我们就有一个集群了（虽然只有两台服务器hhh）

有关锁失效原因分析

由于现在我们部署了多个tomcat，每个tomcat都有一个属于自己的jvm，那么假设在服务器A的tomcat内部，有两个线程，这两个线程由于使用的是同一份代码，那么他们的锁对象是同一个，是可以实现互斥的，但是如果现在是服务器B的tomcat内部，又有两个线程，但是他们的锁对象写的虽然和服务器A一样，但是锁对象却不是同一个，所以线程3和线程4可以实现互斥，但是却无法和线程1和线程2实现互斥，这就是 集群环境下，syn锁失效的原因，在这种情况下，我们就需要使用分布式锁来解决这个问题。