redis解决秒杀问题（单应用）学习笔记

最新推荐文章于 2024-08-21 14:38:29 发布
最新推荐文章于 2024-08-21 14:38:29 发布
阅读量422 收藏 1
点赞数
文章标签： redis 学习 数据库 java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxc852814721/article/details/125364504
版权

redis解决秒杀问题（单应用）

目录

前提了解!

秒杀肯定离不开电商,那么需要了解用户下单的过程.

1、当用户下单时,会把下单的信息存入一张表中,表中有一个字段用于判断该订单当前的状态.

订单表

CREATE TABLE `tb_voucher_order` (
  `id` bigint NOT NULL COMMENT '主键',
  `user_id` bigint unsigned NOT NULL COMMENT '下单的用户id',
  `voucher_id` bigint unsigned NOT NULL COMMENT '购买的代金券id',
  `pay_type` tinyint unsigned NOT NULL DEFAULT '1' COMMENT '支付方式 1：余额支付；2：支付宝；3：微信',
  `status` tinyint unsigned NOT NULL DEFAULT '1' COMMENT '订单状态，1：未支付；2：已支付；3：已核销；4：已取消；5：退款中；6：已退款',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '下单时间',
  `pay_time` timestamp NULL DEFAULT NULL COMMENT '支付时间',
  `use_time` timestamp NULL DEFAULT NULL COMMENT '核销时间',
  `refund_time` timestamp NULL DEFAULT NULL COMMENT '退款时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=COMPACT;

2、主键存在的问题。

该表中的主键id不能够是自增。会导致一些问题：

  • id的规律性太明显（容易被猜到，并进行攻击）
  • 受单表数据库限制

解决方案：使用全局唯一id生成器，它应该具有的特性：

  • 唯一性

  • 高可用（分布式中也可以用）

  • 高性能（能够快速生成）

  • 递增性（保证数据库能够高效的查询）

  • 安全性

3、全局唯一id生成策略：

  • UUID（不规律，字符串）
  • Redis自增
  • snowflake算法（性能很好，依赖于时钟）
  • 数据库自增（单独建一张表记id，相当于redis版，性能不如redis，但可以通过一些方式解决，如提前存入数据库）

redis实现全局唯一id生成器

符号位（0或1） + 时间戳（31 Bit）+ 序列号（32 Bit)

redis自增策略：

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

实现过程

1、自定义起始时间戳

public void test02() {
    //生成自定义时间秒
    LocalDateTime now = LocalDateTime.of(2021,8,24,0,0,0);
    long second = now.toEpochSecond(ZoneOffset.UTC);
    System.out.println(second);
}

//结果得：1629763200

2、全局唯一id生成器编写

/**
 * @Author: songshu
 * @Date: 2022/06/19/13:11
 * @version: v1.0
 */
public class RedisIdWorker {
    //开始时间戳
    private static final long BEGIN_TIMESTAMP = 1629763200L;
    //序列号位数
    private static final int COUNT_BITS = 32;

    private StringRedisTemplate redisTemplate;

    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        this.redisTemplate = stringRedisTemplate;
    }

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

        //生成序列号
        //定义规则，每天一个key，方便统计
        String data = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        long count = redisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + data);

        //拼接并返回
        //时间戳左移32位,并与序列号或（前面的32位就留给了序列号）
        //可能count也会超过32位，所以定义COUNT_BITS
        return timestamp << COUNT_BITS | count;

    }
}

3、测试

@Autowired
private StringRedisTemplate redisTemplate;

private ExecutorService es = Executors.newFixedThreadPool(500);

@Test
public void test03() throws InterruptedException {
    //记时器
    CountDownLatch countDownLatch = new CountDownLatch(300);

    RedisIdWorker redisIdWorker = new RedisIdWorker(redisTemplate);

    Runnable task = () -> {
        for(int i = 0; i < 100; i++) {
            long id = redisIdWorker.nextId("order");
            System.out.println(id);
        }
        countDownLatch.countDown();
    };

    long begin = System.currentTimeMillis();
    //任务提交300次
    for (int i = 0; i < 300; i++) {
        es.submit(task);
    }
    countDownLatch.await();
    long end = System.currentTimeMillis();
    System.out.println("time = " + (end - begin));
}

查看reids中得到：

key为： icr:order:2022:06:19

value为： 30000

实现优惠卷秒杀

优惠卷表

CREATE TABLE `tb_voucher` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `shop_id` bigint unsigned DEFAULT NULL COMMENT '商铺id',
  `title` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '代金券标题',
  `sub_title` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '副标题',
  `rules` varchar(1024) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '使用规则',
  `pay_value` bigint unsigned NOT NULL COMMENT '支付金额，单位是分。例如200代表2元',
  `actual_value` bigint NOT NULL COMMENT '抵扣金额，单位是分。例如200代表2元',
  `type` tinyint unsigned NOT NULL DEFAULT '0' COMMENT '0,普通券；1,秒杀券',
  `status` tinyint unsigned NOT NULL DEFAULT '1' COMMENT '1,上架; 2,下架; 3,过期',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=COMPACT;

库存表

CREATE TABLE `tb_seckill_voucher` (
  `voucher_id` bigint unsigned NOT NULL COMMENT '关联的优惠券的id',
  `stock` int NOT NULL COMMENT '库存',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `begin_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '生效时间',
  `end_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '失效时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`voucher_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=COMPACT COMMENT='秒杀优惠券表，与优惠券是一对一关系';

注意点：

  • 判断秒杀是否开始或结束
  • 库存是否充足

实现下单功能

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

    @Autowired
    private ISeckillVoucherService seckillVoucherService;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        // 获取优惠开始时间和结束时间
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        //判断是否开始
        if(seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
            //尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        //判断是否结束
        if(seckillVoucher.getEndTime().isBefore(LocalDateTime.now())) {
            //已结束
            return Result.fail("秒杀已经结束！");
        }
        //判断库存是否充足
        if(seckillVoucher.getStock() < 1) {
            //库存不足
            return Result.fail("秒杀卷库存不足！");
        }

        //符合以上要求，可以下单
        //库存减一
        LambdaUpdateWrapper<SeckillVoucher> voucherUpdateWrapper = new LambdaUpdateWrapper<>();
        voucherUpdateWrapper.eq(SeckillVoucher::getVoucherId, voucherId);
        voucherUpdateWrapper.setSql("stock = stock-1");
        boolean update = seckillVoucherService.update(voucherUpdateWrapper);
        if(!update) {
            return Result.fail("下单失败！");
        }

        VoucherOrder voucherOrder = new VoucherOrder();
        //生成订单id
        RedisIdWorker redisIdWorker = new RedisIdWorker(redisTemplate);
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        //代金券id
        voucherOrder.setVoucherId(voucherId);
        boolean flag = save(voucherOrder);
        if(!flag) {
            return Result.fail("下单失败！");
        }
        return Result.ok(orderId);
    }
}

该方法存在高并发问题！！！

需要优化！

解决高并发问题

解决方案：

1、通过锁解决

  • 悲观锁
    • Syschronized
    • Lock
  • 乐观锁
    • 数据库加字段 version（版本号法）

乐观锁解决高并发

修改库存表,添加version字段：

ALTER TABLE `tb_seckill_voucher`
ADD COLUMN `version` int(4) NULL DEFAULT 0 COMMENT '乐观锁';

MyBatis-Plus中添加乐观锁插件

注意：

  • 仅支持 updateById(id) 与 update(entity, wrapper) 方法
  • 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!
@Configuration
public class MybatisConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //分页
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 乐观锁
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

修改下单代码

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

    @Autowired
    private ISeckillVoucherService seckillVoucherService;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        // 获取优惠开始时间和结束时间
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        //判断是否开始
        if(seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
            //尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        //判断是否结束
        if(seckillVoucher.getEndTime().isBefore(LocalDateTime.now())) {
            //已结束
            return Result.fail("秒杀已经结束！");
        }
        //判断库存是否充足
        if(seckillVoucher.getStock() < 1) {
            //库存不足
            return Result.fail("秒杀卷库存不足！");
        }


        //符合以上要求，可以下单
        //库存减一
        SeckillVoucher byId = seckillVoucherService.getById(voucherId);
        UpdateWrapper<SeckillVoucher> updateWrapper = new UpdateWrapper<>();
        updateWrapper.setSql("stock = stock-1");
        boolean update = seckillVoucherService.update(byId, updateWrapper);
        if(!update) {
            return Result.fail("下单失败！");
        }

        VoucherOrder voucherOrder = new VoucherOrder();
        //生成订单id
        RedisIdWorker redisIdWorker = new RedisIdWorker(redisTemplate);
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        //代金券id
        voucherOrder.setVoucherId(voucherId);
        boolean flag = save(voucherOrder);
        if(!flag) {
            return Result.fail("下单失败！");
        }
        return Result.ok(orderId);
    }

注意这里会出现问题！

会有大量线程同时拿到同一个version，这就会导致乐观锁的成功率低！！！

乐观锁的特点：

  • 成功率低，效率高

由于是抢票，所以可以直接判断库存是否大于0即可，代码不演示。

新需求：一人抢一票

解决方式：加悲观锁

会遇到的问题：

问题一：

//加悲观锁，
//userid.toString() 底层是重新new一个对象，所以需要使用intern()方法到常量池中获取.

问题二：

//下面方法的事务不能够启用
//由于createVoucherOrder是VoucherOrderServiceImpl的对象，这里调用的是this，
//而不是VoucherOrderServiceImpl的代理对象
//由于spring需要代理对象才能够启用事务

引依赖

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

在启动类上加注解

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

代码：

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

    @Autowired
    private ISeckillVoucherService seckillVoucherService;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public Result seckillVoucher(Long voucherId) {
        // 获取优惠开始时间和结束时间
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        //判断是否开始
        if(seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
            //尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        //判断是否结束
        if(seckillVoucher.getEndTime().isBefore(LocalDateTime.now())) {
            //已结束
            return Result.fail("秒杀已经结束！");
        }
        //判断库存是否充足
        if(seckillVoucher.getStock() < 1) {
            //库存不足
            return Result.fail("秒杀卷库存不足！");
        }

        //解决一人一票
        Long userid = UserHolder.getUser().getId();
        //加悲观锁，
        //userid.toString() 底层是重新new一个对象，所以需要使用intern()方法到常量池中获取
        synchronized (userid.toString().intern()) {
            //下面方法的事务不能够启用
            //由于createVoucherOrder是VoucherOrderServiceImpl的对象，这里调用的是this，
            //而不是VoucherOrderServiceImpl的代理对象
            //由于spring需要代理对象才能够启用事务
            IVoucherOrderService currentProxy = (IVoucherOrderService) AopContext.currentProxy();
            return currentProxy.createVoucherOrder(voucherId, userid);
        }
    }

    @Transactional
    public Result createVoucherOrder(Long voucherId, Long userid) {
        // 判断是否存在该用户够的票
        LambdaQueryWrapper<VoucherOrder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(VoucherOrder::getUserId, userid)
                .eq(VoucherOrder::getVoucherId, voucherId);
        VoucherOrder one = getOne(queryWrapper);
        if(BeanUtil.isNotEmpty(one)) {
            return Result.fail("不可重复抢购！");
        }
        //符合以上要求，可以下单
        //库存减一
        UpdateWrapper<SeckillVoucher> updateWrapper = new UpdateWrapper<>();
        updateWrapper.setSql("stock = stock-1").gt("stock",0);
        boolean update = seckillVoucherService.update(updateWrapper);
        if(!update) {
            return Result.fail("下单失败！");
        }

        VoucherOrder voucherOrder = new VoucherOrder();
        //生成订单id
        RedisIdWorker redisIdWorker = new RedisIdWorker(redisTemplate);
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        //代金券id
        voucherOrder.setVoucherId(voucherId);
        boolean flag = save(voucherOrder);
        if(!flag) {
            return Result.fail("下单失败！");
        }
        return Result.ok(orderId);
    }
}

注意：

该方法是能在单应用中使用，集群中就会出问题！！

songshu。
关注
Redis 之 秒杀案例
weixin_44513658的博客
05-03 1337
利用 Redis 事务 和 锁机制 完成秒杀案例
Redis学习笔记
u014754814的博客
11-07 1444
Redis学习笔记
【Redis】事务和锁 ---秒杀案例，Lua脚本
Java—wang的博客
07-02 296
//秒杀过程 public static boolean doSecKill(String uid,String prodid) throws IOException { //1 uid和prodid非空判断 if(uid == null || prodid == null) { return false; } //2 连接redis //Jedis jedis = new Jedis("192.168.44.168",6379); //通过连接池得到jedis对象 .
Redis实现秒杀
最新发布
沈明沅
08-21 1689
实现一个商品秒杀系统时，可以通过封装类来实现与 MySQL、Redis 的交互，并使用令牌桶算法来控制请求的速率，确保高并发下的系统稳定性。下面是一个示例，展示如何封装这三部分功能来实现商品秒杀。
Redis实现高并发下的抢购、秒杀功能
weixin_30808693的博客
04-27 293
博主最近在项目中遇到了抢购问题！现在分享下。抢购、秒杀是如今很常见的一个应用场景，主要需要解决的问题有两个：1 高并发对数据库产生的压力2 竞争状态下如何解决库存的正确减少（"超卖"问题）对于第一个问题，已经很容易想到用缓存来处理抢购，避免直接操作数据库，例如使用Redis。重点在于第二个问题常规写法：查询出对应商品的库存，看是否大于0，然后执行生成订单等操作，但是在判断库存是否大于0处，如果在高...
秒杀系统涉及问题分析和解决（Redis分布式锁的实现）
weixin_47365232的博客
03-23 2110
Redis的基本事务机制 Redis 事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。 Redis 事务的主要作用就是串联多个命令防止别的命令插队。 Multi、Exec、Discard Multi：该命令其实是一个组队的过程，在输入Multi命令后，输入的命令会依次进入到命令队列，此时并不执行队列中任何一条语句的操作。 Exec：输入Exex命令后，Redis会亮命令队列中的命令依次执行，队列是先进先出。 Discard：在
redis解决商品秒杀问题
qq_38472465的博客
10-22 108
redis解决商品秒杀问题
基于《狂神说Java》Redis--学习笔记
wudidahuanggua的博客
06-19 1690
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!
Redis 个人狂神说视频学习笔记
Ctrl_kun的博客
02-27 3423
该文章为本人观看 狂神说的 Redis视频 时的全部笔记。
Redis学习笔记——（17）Redis面试题及答案
weixin_42510648的博客
12-16 775
redis面试题
redis秒杀
mounttp的博客
02-16 452
秒杀系统的问题 1.短时间内服务负载高 2.高并发超卖 $redis = new \Redis(); if ($redis->connect('127.0.0.1','6379') == false) { die($redis->getLastError()); } 使用redis的原子性操作，保证不多抢 if($_GET['flag']
Redis秒杀
Sartin的博客
06-24 298
Redis秒杀 RedisTest.java package com.hadoop.Redis; import java.util.Random; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import redis.clients.jedis.Jedis; public class RedisTest { public static void main(String[]
Redis -- 秒杀
qq_33753147的博客
08-21 1093
Redis 秒杀 -- 消息队列
Redis事务+Redis锁机制+Redis解决秒杀问题
aaatx的博客
03-08 226
Redis事务+Redis锁机制乐观锁+Redis解决秒杀超卖问题、redis解决库存遗留问题、redis解决请求超时问题。redis lua脚本解决秒杀并发问题。
Redis秒杀事务高并发所产生的问题及解决方案
qmxqing的博客
08-14 418
秒杀事务高并发所产生的问题及解决方案秒杀业务高并发产生的问题问题一:超卖问题解决方式一:采用乐观锁解决方式二: 采用LUA脚本1.1 LUA脚本介绍1.2 特点问题二:由于有些连接等待时间过长会出现连接超时的问题解决方案 秒杀业务高并发产生的问题 问题一:超卖问题 解决方式一:采用乐观锁 采用乐观锁, watch 监视库存, 同时将秒杀操作采用事务管理,解决超卖问题,不过会存在库存遗留问题 缺点: 采用乐观锁方式会存在库存遗留问题 解决方式二: 采用LUA脚本 1.1 LUA脚本介绍 LUA脚本是类
Redis实现商品秒杀
千里之行，始于足下
03-19 1074
Redis是一款非关系数据库，数据存储在内存中，存取数据速度非常快！ Redis是单线程的，即使在同一时间有多条命令操作数据库，这些命令依然只能排队等候。
redis解决秒杀问题
07-27
Redis可以用来解决秒杀问题的原因是其高性能和支持原子操作的特性。下面是使用Redis解决秒杀问题的一般步骤： 1. 商品库存初始化：在Redis中设置一个键值对，键表示商品ID，值表示商品的库存数量。 2. 用户秒杀...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值