首页 > 数据库 > Redis > Redis分布式缓存与秒杀

Redis分布式缓存与秒杀

福牛 4月 03, 2023 28 0

一、单点Redis的问题

1、数据丢失问题

Redis数据持久化。

2、并发能力问题

大家主从集群，实现读写分离。

3、故障恢复问题

利用Redis哨兵，实现健康检测和自动恢复。

4、存储能力问题

搭建分片集群，利用插槽机制实现动态扩容。

二、RDB

RDB全称Redis Database Backup file（Redis数据备份文件），也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。
快照文件称为RDB文件，默认是保存在当前运行目录。

Redis内部有触发RDB的机制，可以在redis.conf文件中找到，格式如下：

-1

bgsave开始时会fork主进程得到子进程，子进程共享主进程的内存数据。完成fork后读取内存数据并写入 RDB 文件。

fork采用的是copy-on-write技术：

  • 当主进程执行读操作时，访问共享内存；
  • 当主进程执行写操作时，则会拷贝一份数据，执行写操作；

RDB方式bgsave的基本流程？

  1. fork主进程得到一个子进程，共享内存空间；
  2. 子进程读取内存数据并写入新的RDB文件；
  3. 用新RDB文件替换旧的RDB文件；

-2

RDB会在什么时候执行？save 60 1000代表什么含义？

  • 默认是服务停止时；
  • 代表60秒内至少执行1000次修改则触发RDB；

RDB的缺点？

  • RDB执行间隔时间长，两次RDB之间写入数据有丢失的风险；
  • fork子进程、压缩、写出RDB文件都比较耗时；

AOF的命令记录的频率也可以通过redis.conf文件来配：

三、AOF

AOF全称为Append Only File（追加文件）。Redis处理的每一个写命令都会记录在AOF文件，可以看做是命令日志文件。

AOF默认是关闭的，需要修改redis.conf配置文件来开启AOF：

-3

AOF的命令记录的频率也可以通过redis.conf文件来配：

-4

配置项 刷盘时机 优点 缺点
Always 同步刷盘 可靠性高，几乎不丢数据 性能影响大
everysec 每秒刷盘 性能适中 最多丢失一分钟的数据
no 操作系统控制 性能最好 可靠性较差，可能丢失大量数据

因为是记录命令，AOF文件会比RDB文件大的多。而且AOF会记录对同一个key的多次写操作，但只有最后一次写操作才有意义。通过执行bgrewriteaof命令，可以让AOF文件执行重写功能，用最少的命令达到相同效果。

  1. set id 1
  2. set name nezha
  3. set id 2
  4.  
  5. bgrewriteaof
  6.  
  7. mset name nezha id 2

Redis也会在触发阈值时自动去重写AOF文件。阈值也可以在redis.conf中配置：

# AOF文件比上次文件 增长超过多少百分比则触发重写auto-aof-rewrite-percentage 100# AOF文件体积最小多大以上才触发重写 auto-aof-rewrite-min-size 64mb

RDB和AOF各有自己的优缺点，如果对数据安全性要求较高，在实际开发中往往会结合两者来使用。

RDB AOF
持久化方式 定时对整个内存做快照 记录每一次执行的命令
数据完整性 不完整，两次备份之间会丢失 相对完整，取决于刷盘策略
文件大小 会有压缩，文件体积小 记录命令，文件体积很大
宕机恢复速度 很快 慢
数据恢复优先级 低，因为数据完整性不低 高，因为数据完整性更高
系统资源占用 高，大量CPU和内存消耗 低，主要是磁盘IO资源，但AOF重写时会占用大量CPU和内存资源
使用场景 可以容忍数分钟的数据丢失，追求更快的启动速度 对数据安全性要求较高常见

四、Redis优化秒杀流程

1、秒杀步骤：

  1. 查询优惠券；
  2. 判断秒杀商品库存；
  3. 查询订单
  4. 校验一人一单；
  5. 减库存；
  6. 创建订单；

-5

2、Redis优化秒杀步骤：

  1. 新增秒杀的优惠券，将优惠券信息保存到Redis中；
  2. 基于Lua脚本，判断秒杀商品库存，一人一单，决定用户是否秒杀成功；
  3. 如果秒杀成功，将优惠券id、用户id、商品id封装到阻塞队列中；
  4. 开启异步任务，不断从阻塞队列中读取信息，实现异步下单功能；

-6

3、秒杀的lua脚本

-7

 4、调用秒杀的lua脚本

  1. public Result seckillVoucher(Long voucherId) {
  2.          Long userId = UserHolder.getUser().getId();
  3.          long orderId = redisIdworker.nextId(“order”);
  4.          // 1.执行lua脚本
  5.          Long result = stringRedisTemplate.execute(
  6.                  SECKILL_SCRIPT,
  7.                  Collections.emptyList(),
  8.                  voucherId.toString(), userId.toString(), String.valueOf(orderId)
  9.          );
  10.          int r = result.intValue();
  11.          // 2.判断结果是否为0
  12.          if (r != 0) {
  13.              // 2.1.不为0 ，代表没有购买资格
  14.              return Result.fail(r == 1 ? “库存不足” : “不能重复下单”);
  15.          }
  16.          // 3.返回订单id
  17.          return Result.ok(orderId);
  18.      }

5、通过线程池，操作阻塞队列

  1. // 线程池
  2. private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
  3.  
  4. /**
  5. * 在类初始化完成后执行
  6. */
  7. @PostConstruct
  8. private void init() {
  9.      SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
  10. }
  11.  
  12. // 阻塞队列
  13. private blockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
  14. private class OrderHandler implements Runnable{
  15.  
  16.      @Override
  17.      public void run() {
  18.          while (true){
  19.              try {
  20.                  DOSomething();
  21.              } catch (Exception e) {
  22.                  log.error(“处理订单异常”, e);
  23.              }
  24.          }
  25.      }
  26. }

五、基于Redis实现共享session登录

基于session实现登录

-8

基于Redis实现共享session登录

  1. public class RefreshTokenInterceptor implements HandlerInterceptor {
  2.  
  3.      private StringRedisTemplate stringRedisTemplate;
  4.  
  5.      public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
  6.          this.stringRedisTemplate = stringRedisTemplate;
  7.      }
  8.  
  9.      @Override
  10.      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  11.          // 1、获取请求头中的token
  12.          String token = request.getHeader(“authorization”);
  13.          if (StrUtil.isBlank(token)) {
  14.              return true;
  15.          }
  16.          // 2、基于TOKEN获取redis中的用户
  17.          String key = LOGIN_USER_KEY + token;
  18.          Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
  19.          // 3、判断用户是否存在
  20.          if (userMap.isEmpty()) {
  21.              return true;
  22.          }
  23.          // 5、将查询到的hash数据转为UserDTO
  24.          UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
  25.          // 6、存在，保存用户信息到 ThreadLocal
  26.          UserHolder.saveUser(userDTO);
  27.          // 7、刷新token有效期
  28.          stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
  29.          // 8、放行
  30.          return true;
  31.      }
  32.  
  33.      @Override
  34.      public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  35.          // 移除用户
  36.          UserHolder.removeUser();
  37.      }
  38. }

-9

到此这篇关于Redis分布式缓存与秒杀的文章就介绍到这了,更多相关Redis分布式缓存秒杀内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论