黑马点评:优惠券秒杀

文章目录

    • 全局唯一ID
      • 全局ID生成器
    • Redis实现全局唯一Id
      • 代码实现
      • 代码分析
      • 测试
      • 知识小贴士:关于countdownlatch
    • 添加优惠卷
      • 测试
    • 实现秒杀下单
      • 测试
    • 库存超卖问题分析
      • 测试(未加锁):三个坑
    • 乐观锁解决超卖问题
      • 修改代码方案一
      • 修改代码方案二
      • 知识小扩展
    • 优惠券秒杀-一人一单
      • 初步代码:增加一人一单逻辑
        • 测试
      • synchronized 锁
        • 基础
        • 进阶
        • 高级
        • 完整代码
        • 测试
    • 集群环境下的并发问题
      • 锁失效原因分析
    • 总结

全局唯一ID

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

黑马点评:优惠券秒杀_第1张图片

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

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

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

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

全局ID生成器

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

黑马点评:优惠券秒杀_第2张图片

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

黑马点评:优惠券秒杀_第3张图片

ID的组成部分:符号位:1bit,永远为0

时间戳:31bit,以秒为单位,可以使用69年

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

Redis实现全局唯一Id

代码实现

package com.hmdp.utils;

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;

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

代码分析

全局唯一ID组成部分:时间戳 + 序列号

ID 64 位,那就是 Long 类型

生成策略:基于Redis 自增长

  1. 生成时间戳

    • 开始时间

          public static void main(String[] args) {
              LocalDateTime time = LocalDateTime.of(2022, 1, 1, 0, 0, 0);
              long second = time.toEpochSecond(ZoneOffset.UTC);
              System.out.println("second: "+second);
          }
      
    • 当前时间

      LocalDateTime now = LocalDateTime.now();
              long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
      

    二者相减生成时间戳

  2. 生成序列号

    • 错误写法:

      Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" );
      
      • 一个业务里每条数据的 key 都一样了,比如订单业务,keyPrefix = order,每个订单key 相同
      • 序列号只有32位,这样写可能不够用
    • 正确写法:

      在 key 后面 + 日期

      • 日期 以年月日格式

        • 方便查看某一年、某一月、某天的订单量

        • 不用担心 id 不够用(32位足够)

              String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
              Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
      
    • 妙啊

  3. 拼接:

    错误写法:

    • 以字符串形式拼接
      • 返回类型:Long

    要求:id 高位:时间戳、低位:序列号

    正确写法:

    • 位运算

      • 时间戳 向左移动 32 位,原先的 32 位用 0 填充
      • 如何 把序列号移到时间戳的低位上?
      • 或运算
        • 时间戳低(32)位全为0,而 0 与任何数 或运算 都为 对方
        • 0 或 0 = 0、 0 或 1 = 1
      • 时间戳先向左移空出来位置,之后或运算,把序列号保留下来
            return timeStamp << 32 | count;
      

测试

package com.hmdp;

import com.hmdp.entity.Shop;
import com.hmdp.service.impl.ShopServiceImpl;
import com.hmdp.utils.CacheClient;
import com.hmdp.utils.RedisIdWorker;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.CACHE_SHOP_KEY;

@SpringBootTest
class HmDianPingApplicationTests {

    @Resource
    private RedisIdWorker redisIdWorker;

    private ExecutorService es = 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++) {
            es.submit(task);
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("time: "+(end - begin));
    }
}

idea:

黑马点评:优惠券秒杀_第4张图片

redis:

黑马点评:优惠券秒杀_第5张图片

知识小贴士:关于countdownlatch

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

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

CountDownLatch 中有两个最重要的方法

1、countDown

2、await

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

添加优惠卷

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

image-20230131195950570

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

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

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

新增普通卷代码

VoucherController:addVoucher

    @Resource
    private IVoucherService voucherService;

    /**
     * 新增普通券
     * @param voucher 优惠券信息
     * @return 优惠券id
     */
    @PostMapping
    public Result addVoucher(@RequestBody Voucher voucher) {
        voucherService.save(voucher);
        return Result.ok(voucher.getId());
    }

新增秒杀卷代码:

VoucherController:addSeckillVoucher

    /**
     * 新增秒杀券
     * @param voucher 优惠券信息,包含秒杀信息
     * @return 优惠券id
     */
    @PostMapping("seckill")
    public Result addSeckillVoucher(@RequestBody Voucher voucher) {
        voucherService.addSeckillVoucher(voucher);
        return Result.ok(voucher.getId());
    }

VoucherServiceImpl

    //IVoucherService:void addSeckillVoucher(Voucher voucher);

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

测试

request:http://localhost:8081/voucher/seckill

{
    "shopId": 1,
    "title": "100元代金券",
    "subTitle": "周一到周日均可使用",
    "rules": "全场通用\\n无需预约\\n可无限叠加\\不兑现、不找零\\n仅限堂食",
    "payValue": 8000,
    "actualValue": 10000,
    "type": 1,
    "stock": 100,
    "beginTime":"2023-01-31T20:40:00",
    "endTime":"2023-01-31T22:40:00"
}

注意:payValue 和 actualValue 单位是 分,这样做是为了避免有小数,8000 分 = 80 元,payValue / actualValue 为8折

postman:

黑马点评:优惠券秒杀_第6张图片

mysql:

黑马点评:优惠券秒杀_第7张图片

前端页面:

黑马点评:优惠券秒杀_第8张图片

测试通过!

实现秒杀下单

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

黑马点评:优惠券秒杀_第9张图片

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

下单时需要判断两点:

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

下单核心逻辑分析:

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

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

黑马点评:优惠券秒杀_第10张图片

VoucherOrderServiceImpl

package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDateTime;


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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    @Override
    @Transactional
    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 id = UserHolder.getUser().getId();
        voucherOrder.setUserId(id);
        //6.3.代金券id
        voucherOrder.setVoucherId(voucherId);
        // 7.保存订单
        save(voucherOrder);
        // 8.返回订单id
        return Result.ok(orderId);
    }
}

测试

前端页面进入“688茶餐厅”,抢购秒杀优惠券

  • 前端页面显示抢购成功
  • 数据库插入相应数据

测试通过!

黑马点评:优惠券秒杀_第11张图片

库存超卖问题分析

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

 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,那么这两个线程都会去扣减库存,最终多个线程相当于一起去扣减库存,此时就会出现库存的超卖问题。

黑马点评:优惠券秒杀_第12张图片

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

黑马点评:优惠券秒杀_第13张图片

悲观锁:

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

乐观锁:

乐观锁:会有一个版本号,每次操作数据会对版本号+1,再提交回数据时,会去校验是否比之前的版本大1 ,如果大1 ,则进行操作成功,这套机制的核心逻辑在于,如果在操作过程中,版本号只比原来大1 ,那么就意味着操作过程中没有人对他进行过修改,他的操作就是安全的,如果不大1,则数据被修改过,当然乐观锁还有一些变种的处理方式比如cas

乐观锁的典型代表:就是cas,利用cas进行无锁化机制加锁,var5 是操作前读取的内存值,while中的var1+var2 是预估值,如果预估值 == 内存值,则代表中间没有被人修改过,此时就将新值去替换 内存值

其中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无法执行成功

黑马点评:优惠券秒杀_第14张图片

测试(未加锁):三个坑

  1. 恢复数据

    • tb_voucher_order:删除已有记录
    • tb_seckill_voucher: stock 修改为 100
  2. jmeter 测试

    • 打开jmeter,导入秒杀抢购.jmx
  3. 启动

    • 第一坑:401未授权

    • 第二坑:秒杀已过期

    • 第三坑:获取登录用户id空指针

       //Long id = UserHolder.getUser().getId();手动添加id
              voucherOrder.setUserId(666L);
      
  4. 报错

    jmeter:

    黑马点评:优惠券秒杀_第15张图片

    postman:

    黑马点评:优惠券秒杀_第16张图片

  5. 修改拦截器配置(第一坑)

    • 401:未授权的意思,和403差不多
    • 拦截器配置:voucher-order 下所有方法放行

    黑马点评:优惠券秒杀_第17张图片

  6. 重启测试

    还是报错

    postman测试:

    黑马点评:优惠券秒杀_第18张图片

    修改数据库秒杀券的结束时间:省略(第二坑)

  7. 再次测试

    接着报错

    黑马点评:优惠券秒杀_第19张图片

    启动Nginx,打开前端页面后登录

  8. 还是空指针异常(第三坑)

    • 由于使用 Threadlocal 保存用户信息,防止内存泄漏,拦截器配有删除用户信息
    • 鉴于此,我们手动写死id,仅仅为了测试

    黑马点评:优惠券秒杀_第20张图片

  9. 重启测试

    这次终于成功了!!!

    mysql:

    黑马点评:优惠券秒杀_第21张图片

    jmeter:

    黑马点评:优惠券秒杀_第22张图片

    结果说明:超卖

  10. 测试通过

    • 这次主要是搭建测试环境,把坑踩一遍,接下来就顺畅多了

乐观锁解决超卖问题

修改代码方案一

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 = ?

以上逻辑的核心含义是:只要我扣减库存时的库存和之前我查询到的库存是一样的,就意味着没有人在中间修改过库存,那么此时就是安全的,但是以上这种方式通过测试发现会有很多失败的情况,失败的原因在于:在使用乐观锁过程中假设100个线程同时都拿到了100的库存,然后大家一起去进行扣减,但是100个人中只有1个人能扣减成功,其他的人在处理时,他们在扣减时,库存已经被修改过了,所以此时其他线程都会失败

测试

  1. jmeter报错

    黑马点评:优惠券秒杀_第23张图片

  2. 恢复数据

  3. 再次测试

    jmeter

    黑马点评:优惠券秒杀_第24张图片

    mysql

    黑马点评:优惠券秒杀_第25张图片

  4. 测试通过

    • 虽然异常率很高,但也一定有抢到秒杀券的,不会 100% 异常

修改代码方案二

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

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

注意:这种只能保证不超卖,但对每个线程抢购秒杀券的次数没有限制,即一人多单

测试

  1. 恢复数据

  2. 启动测试

    jmeter

    黑马点评:优惠券秒杀_第26张图片

    mysql:正常

    省略(100条订单数据,库存为0)

  3. 测试成功!

知识小扩展

针对cas中的自旋压力过大,我们可以使用Longaddr这个类去解决

Java8 提供的一个对AtomicLong改进后的一个类,LongAdder

大量线程并发更新一个原子性的时候,天然的问题就是自旋,会导致并发性问题,当然这也比我们直接使用syn来的好

所以利用这么一个类,LongAdder来进行优化

如果获取某个值,则会对cell和base的值进行递增,最后返回一个完整的值

图解:

黑马点评:优惠券秒杀_第27张图片

优惠券秒杀-一人一单

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

现在的问题在于:

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

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

黑马点评:优惠券秒杀_第28张图片

初步代码:增加一人一单逻辑

package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDateTime;


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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    @Override
    @Transactional
    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).eq("stock",voucher.getStock()).update(); //where id = ? and stock = ?
        boolean success = seckillVoucherService.update()
                .setSql("stock= stock -1")
                .eq("voucher_id", voucherId).gt("stock",0).update(); //where id = ? and stock > 0
        if (!success){
            //扣减库存
            return Result.fail("库存不足!");
        }
        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 7.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 7.2.用户id
        Long id = UserHolder.getUser().getId();
        voucherOrder.setUserId(id);
        //7.3.代金券id
        voucherOrder.setVoucherId(voucherId);
        // 8.保存订单
        save(voucherOrder);
        // 9.返回订单id
        return Result.ok(orderId);
    }
}
测试

首先纠正下之前的测试方法:把登录用户ID写死的错误写法,由于之前未使用过jmeter,不知道可以传token

jmeter:

黑马点评:优惠券秒杀_第29张图片

浏览器:

黑马点评:优惠券秒杀_第30张图片

在黑马点评:短信登录部分老师讲过,前端页面向后端发送数据时携带authorization,忘了的小伙伴可以看我之前的笔记

把jmeter登录状态头里authorization对应的值修改为浏览器里的token值,这样每个线程请求时都会携带登录用户信息(同一个用户),测试一人一单

测试初步代码

  1. 恢复数据(库存100,订单0)

  2. jmeter测试

    黑马点评:优惠券秒杀_第31张图片

    mysql:

    黑马点评:优惠券秒杀_第32张图片

  3. 测试成功

    • 正常情况:库存:99,订单数:1
    • 异常情况:如上
    • 存在问题:超卖

synchronized 锁

存在问题:现在的问题还是和之前一样,并发过来,查询数据库,都不存在订单,所以我们还是需要加锁,但是乐观锁比较适合更新数据,而现在是插入数据,所以我们需要使用悲观锁操作

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

基础

哪部分代码加锁?

  • 查询订单
  • 判断订单是否存在
  • 新增订单

把以上代码封装为一个单独的方法,加锁和事务

错误加锁:

  • 在方法上加锁,锁的是this,指的是当前对象,方法上加锁,会导致线程串行执行,性能大大降低

  • 举个栗子:

  • 张三,李四访问,这样加锁会导致张三执行完李四才可以执行

  • 我们要的是:锁住单独用户,一个用户只能下一单,张三和李四可以并行执行,只要张三和李四都只下一单即可

正确加锁

  • 锁住的应该是当前用户

  • 使用用户id加锁,锁的范围变小

  • 同一用户,加同一把锁,不同用户,加不同锁

下面代码为错误加锁

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

这样添加锁,锁的粒度太粗了,在使用锁过程中,控制锁粒度 是一个非常重要的事情,因为如果锁的粒度太大,会导致每个线程进来都会锁住,所以我们需要去控制锁的粒度,以上这段代码需要修改

synchronized(userId.toString())

期望:userId 值一样的为同一把锁

每次请求过来 userId 都是不一样的对象,对象变了,锁就变了,我们要求的是值一样,所以toString()

查看 toString() 源码:

每次都是 new一个新的对象,即便userId 相同,userId.toString()也不同

黑马点评:优惠券秒杀_第33张图片

intern() 这个方法是从常量池中拿到数据,如果我们直接使用userId.toString() 他拿到的对象实际上是不同的对象,new出来的对象,我们使用锁必须保证锁必须是同一把,所以我们需要使用intern()方法

黑马点评:优惠券秒杀_第34张图片

@Transactional
public  Result createVoucherOrder(Long voucherId) {
	Long userId = UserHolder.getUser().getId();
    //synchronized(userId.toString()){
	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);
    }
}
高级

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

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

要求:先获取锁,之后提交事务,最后释放锁

黑马点评:优惠券秒杀_第35张图片

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

黑马点评:优惠券秒杀_第36张图片

完整代码
package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;

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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

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

        Long userId = UserHolder.getUser().getId();
        synchronized(userId.toString().intern()) {
            // 获取代理对象 事务
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
    }
    @Transactional
    public Result createVoucherOrder(Long voucherId){

        // 5.一人一单逻辑
        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")
                    .eq("voucher_id", voucherId).gt("stock", 0).update(); //where id = ? and stock > 0
            if (!success) {
                //扣减库存
                return Result.fail("库存不足!");
            }
            // 7.创建订单
            VoucherOrder voucherOrder = new VoucherOrder();
            // 7.1.订单id
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            // 7.2.用户id
            Long id = UserHolder.getUser().getId();
            voucherOrder.setUserId(id);
            //7.3.代金券id
            voucherOrder.setVoucherId(voucherId);
            // 8.保存订单
            save(voucherOrder);

            return Result.ok(orderId);

    }
}

pom.xml

        <--!>添加动态代理--!>
		<dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
        dependency>

启动类

//暴露代理对象
@EnableAspectJAutoProxy(exposeProxy = true)

需要掌握:动态代理、AOP、事务、悲观锁、锁的范围等等

知识小贴士

  • spring框架事务失效
  • aop代理对象
  • synchronized锁对象
测试
  1. 恢复数据库数据

  2. 重启测试

    jmeter

    黑马点评:优惠券秒杀_第37张图片

    mysql

    黑马点评:优惠券秒杀_第38张图片

  3. 成功锁上!

集群环境下的并发问题

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

  1. 我们将服务启动两份,端口分别为8081和8082:

    黑马点评:优惠券秒杀_第39张图片

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

    黑马点评:优惠券秒杀_第40张图片

  3. 让Nginx配置文件生效

    黑马点评:优惠券秒杀_第41张图片

  4. 测试是否配置成功

    • 浏览器输入:http://localhost:8888/api/voucher/list/1

    • 刷新两次:看到8001服务和8003服务各一次

    • 配置成功!

  5. 测试锁

    • 恢复数据
    • 懒得复制authorization,使用jmeter测试
  6. jmeter配置

    黑马点评:优惠券秒杀_第42张图片

  7. 测试

    jmeter

    黑马点评:优惠券秒杀_第43张图片

    mysql

    黑马点评:优惠券秒杀_第44张图片

  8. 测试成功

经多次测试,并不一定锁失效,也有正常的情况!!!

锁失效原因分析

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

黑马点评:优惠券秒杀_第45张图片

总结

  1. 秒杀优惠券的基本实现

  2. 超卖问题

  3. 基于乐观锁解决超卖问题(乐观锁和悲观锁)

  4. 秒杀的一人一单限制功能

  5. 实现秒杀的一人一单限制

  6. 单机模式下的线程安全问题

  7. 集群模式下的线程安全问题

Synchronized锁和Lock锁

  • 萌新必入!手把手教你玩转Synchronized锁和Lock锁!
  • JUC多线程:synchronized锁机制原理 与 Lock锁机制

CountDownLatch

  • CountDownLatch 是什么?怎么用?
  • CountDownLatch用法详解

悲观锁和乐观锁

  • 悲观锁与乐观锁的实现(详情图解)
  • 面试必备之乐观锁与悲观锁

你可能感兴趣的:(数据库,java,redis,mysql)