当前位置： 首页 > article >正文

Redis实战-优惠券秒杀

article 2024/10/9 2:36:19

Redis实战篇-短信登入

该笔记是来源于黑马程序员的Redis项目课程,为了后续方便复习。将笔记记录在博客之中
实战篇我们要学习一些什么样的内容

1.本期任务

  • 短信登入

使用redis共享session来实现

  • 商户查询缓存

理解缓存击穿，缓存穿透，缓存雪崩等问题

  • 优惠卷秒杀

通Redis的计数器功能， 结合Lua完成高性能的redis操作，同时学会Redis分布式锁的原理，包括Redis的三种消息队列

  • 附近的商户

利用Redis的GEOHash来完成对于地理坐标的操作

  • UV统计

使用Redis来完成统计功能

  • 用户签到

使用Redis的BitMap数据统计功能

  • 好友关注

基于Set集合的关注、取消关注，共同关注等等功能

  • 人探店

基于List来完成点赞列表的操作，同时基于SortedSet来完成点赞的排行榜功能

请添加图片描述

2 全局唯一ID

订单表如果使用数据库自增ID就存在一些问题：

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

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

全局ID生成器，是一种在分布式系统下用来生成全局唯一ID的工具，一般要满足下列特性：
请添加图片描述
为了增加ID的安全性，我们可以不直接使用Redis自增的数值，而是拼接一些其它信息：请添加图片描述
ID的组成部分：符号位：1bit，永远为0

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

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

3 编码实现全局唯一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;

/**
 * 基于Redis实现的ID生成器
 */
@Component
public class RedisIdWorker {

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

    // 起始时间戳 (2022-01-01 00:00:00 UTC)
    private static final long BEGIN_TIMESTAMP = 1640995200L;

    // Redis操作模板
    private StringRedisTemplate redisTemplate;

    /**
     * 构造函数，注入StringRedisTemplate
     *
     * @param redisTemplate Redis模板
     */
    public RedisIdWorker(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 生成下一个ID
     *
     * @param keyPrefix ID前缀
     * @return 下一个ID
     */
    public long nextId(String keyPrefix){
        // 1. 生成当前时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        // 2. 生成日期字符串和序列号
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        long increment = redisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        // 3. 拼接时间戳和序列号，并返回
        return timestamp << COUNT_BITS | increment;
    }
}

知识小贴士：关于countdownlatch

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

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

CountDownLatch 中有两个最重要的方法

1、countDown

2、await

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

测试类:

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 CacheClient cacheClient;

    @Resource
    private ShopServiceImpl service;

    @Resource
    private RedisIdWorker redisIdWorker;

    // 创建一个固定大小的线程池
    private ExecutorService es = Executors.newFixedThreadPool(500);

    /**
     * 测试ID生成器的性能
     * 使用300个线程并发生成订单ID
     */
    @Test
    void testIdWorker() throws InterruptedException {
        // 创建计数器，初始值为300
        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();

        // 提交300个任务到线程池
        for (int i = 0; i < 300; i++) {
            es.submit(task);
        }

        // 等待所有任务完成
        latch.await();

        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - begin));
    }
}

4 添加优惠券

普通券和优惠券是两种不同的券，优惠券拥有普通券的所有字段，比普通券多了库存，开始时间和结束时间

普通优惠券

@PostMapping
public Result addVoucher(@RequestBody Voucher voucher) {
	//普通的无所谓,直接调用mybatisplus的方法添加即可
    voucherService.save(voucher);
    return Result.ok(voucher.getId());
}

秒杀卷

@PostMapping("seckill")
public Result addSeckillVoucher(@RequestBody Voucher voucher) {
	//秒杀券的业务逻辑比较复杂，需要自定义接口实现
    voucherService.addSeckillVoucher(voucher);
    return Result.ok(voucher.getId());
}

@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) {
    // 保存优惠券信息到数据库
    save(voucher);

    // 创建秒杀优惠券对象
    SeckillVoucher seckillVoucher = new SeckillVoucher();
    //秒杀券的Id就是优惠券的Id
    seckillVoucher.setVoucherId(voucher.getId()); // 设置优惠券ID
    seckillVoucher.setStock(voucher.getStock()); // 设置库存数量
    seckillVoucher.setBeginTime(voucher.getBeginTime()); // 设置开始时间
    seckillVoucher.setEndTime(voucher.getEndTime()); // 设置结束时间

    // 保存秒杀优惠券信息到数据库
    seckillVoucherService.save(seckillVoucher);
}

5 实现秒杀下单

下单核心逻辑分析：

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

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

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

}

6 库存超卖问题

假设线程1过来查询库存，判断出来库存大于1，正准备去扣减库存，但是还没有来得及去扣减，此时线程2过来，线程2也去查询库存，发现这个数量一定也大于1，那么这两个线程都会去扣减库存，最终多个线程相当于一起去扣减库存，此时就会出现库存的超卖问题。请添加图片描述
超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁：而对于加锁，我们通常有两种解决方案：见下图：请添加图片描述
悲观锁：

悲观锁可以实现对于数据的串行化执行悲观锁中又可以再细分为公平锁，非公平锁，可重入锁，等等

乐观锁：

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

课程中的使用方式：

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

7 乐观锁解决超卖问题

修改代码方案一、
VoucherOrderServiceImpl 在扣减库存时，改为：

boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1") 
            .eq("voucher_id", voucherId)
            .eq("stock",voucher.getStock()).update();

只要我扣减库存时的库存和之前我查询到的库存(voucher.getStock())是一样的，就意味着没有人在中间修改过库存，那么此时就是安全的。
但是以上这种方式通过测试发现会有很多失败的情况，失败的原因在于：在使用乐观锁过程中假设100个线程同时都拿到了100的库存，然后大家一起去进行扣减，但是100个人中只有1个人能扣减成功，其他的人在处理时，他们在扣减时，库存已经被修改过了，所以此时其他线程都会失败
如果此时库存还剩100，那么其实这100个请求是都可以同意的

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

boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId)
            .gt("stock",0)
            .update();

8 优惠券秒杀-一人一单

本期视频(第54集)值得反复观看

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

现在的问题在于：

主要逻辑：根据优惠卷id和用户id查询是否已经下过这个订单，如果下过这个订单，则不再下单，否则进行下单

请添加图片描述

@Transactional
@Override
public Result seckillVoucher(Long voucherId) {
    // 1.查询优惠券
   
    // 2.判断秒杀是否开始
   
    // 3.判断秒杀是否已经结束
   
    // 4.判断库存是否充足
    ...//这里以上的内容不变
    // 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，扣减库存
    
    //7.创建订单
   
    
    // 7.3.代金券id
   

}

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

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

首先我们的初始方案是把从一人一单以后的逻辑抽取出来,封装一个createVoucherOrder方法，同时为了确保他线程安全，在方法上添加了一把synchronized 锁,原本的@Transactional从seckillVoucher放到createVoucherOrder,在seckillVoucher内部对应的位置直接调用createVoucherOrder。


@Override
    public Result seckillVoucher(Long voucherId) {
        //1.查询优惠券
       
        //2.判断是否在规定时间里
       
        //3.判断库存是否冲去
        return createVoucherOrder(voucherId);
    }

@Transactional
public synchronized Result createVoucherOrder(Long voucherId) {

	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.扣减库存
        // 7.创建订单
        // 7.1.订单id
        // 7.2.用户id
        // 7.3.代金券id
        // 7.返回订单id
        return Result.ok(orderId);
}

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

如果锁用户Id,需要传入一个字符串,但string是不可变类型，每次都会new一个新对象,所以使用intern()方法,intern() 这个方法是从常量池中拿到数据，如果我们直接使用userId.toString() 他拿到的对象实际上是不同的对象，new出来的对象。

@Transactional
public (这里的锁删掉,加到底下用户Id) Result createVoucherOrder(Long voucherId) {
	Long userId = UserHolder.getUser().getId();
	synchronized(userId.toString().intern()){
         // 5.1.查询订单
        // 5.2.判断是否存在
        // 6.扣减库存
        // 7.创建订单
        // 7.1.订单id
        // 7.2.用户id
        // 7.3.代金券id
        // 7.返回订单id
        return Result.ok(orderId);
    }
}

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

在seckillVoucher 方法中，添加以下逻辑，这样就能保证事务的特性，同时也控制了锁的粒度请添加图片描述
但是以上做法依然有问题，因为你调用的方法，其实是this.的方式调用的，事务想要生效，还得利用代理来生效，所以这个地方，我们需要获得原始的事务对象， 来操作事务
在这里插入图片描述
同时要引入依赖，引入配置

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

package com.hmdp;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
//在这里暴露代理对象
@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.hmdp.mapper")
@SpringBootApplication
public class HmDianPingApplication {
    public static void main(String[] args) {
        SpringApplication.run(HmDianPingApplication.class, args);
    }
}

http://www.kler.cn/news/339219.html

相关文章：

  • Java中对象和对象变量
  • 数据结构篇（绪论）
  • k8s 中存储之 NFS 卷
  • 老房装修换窗需要注意哪些方面？
  • 学习使用Cube软件
  • 简易CPU设计入门：取指令（四）
  • 【代码随想录Day37】动态规划Part06
  • 【C语言】指针和数组的内存使用详解
  • IIOT工业物联网的标准与互操作性—SunIOT
  • Redis面试篇1
  • 计算机网络：物理层 —— 信道复用技术
  • 20.Nginx动静分离原理与案例实现
  • 极端天气道路目标检测数据集 3400张 带标注 VOC YOLO 6类
  • Javascript-标准内置对象-值属性-globalThis-Infinity-Nan-undefined 手写实现globalThis功能
  • java8 双冒号（::）使用方法
  • 解决方案：Pandas里面的loc跟iloc，有什么区别
  • VSCode调试Vue项目方法
  • 2024四大剪辑软件推荐及下载地址介绍！
  • 关键字：extern
  • 面试题：Redis（一）