Redis
缓存挑战与解决方案
缓存击穿

缓存穿透

概述

大量的请求同时查询一个 Key 时，此时这个 Key 正好失效，就会导致大量的请求都会打到数据库上。

危害

会造成某一时刻数据库请求量过大，压力剧增。

解决

缓存击穿 → 热点 Key 失效 → 互斥更新、随机退避、差异失效时间

热点 Key 失效

  • 时间到了自然清除，但是还被访问到
  • delete 掉的 Key，刚巧又被访问

方案一：差异失效时间，对于访问频繁的热点 Key，干脆就不设置过期时间

方案二：互斥更新，采用双检加锁策略

案例

模拟高并发的天猫聚划算案例

分析过程

步骤说明
1100% 高并发，绝对不可以用 MySQL 实现；
2先把 MySQL 里面参加活动的数据抽取进 Redis，一般采用定时器扫描来绝对上线活动还是下线取消；
3支持分页功能，一页 20 条记录。

高并发 + 定时任务 + 分页显示

Redis 数据结构选型

List 数据结构

Sprint Boot + redis 实现高并发的聚划算业务

示例

Product.java
package dev.matrixlab.redis7.entities;
 
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "聚划算活动producet信息")
public class Product {
    //产品ID
    private Long id;
    //产品名称
    private String name;
    //产品价格
    private Integer price;
    //产品详情
    private String detail;
}
JHSTaskService.java
package dev.matrixlab.redis7.service;
 
import cn.hutool.core.date.DateUtil;
import dev.matrixlab.redis7.entities.Product;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
 
// 采用定时器将参与聚划算活动的特价商品新增进入 redis 中
@Service
@Slf4j
public class JHSTaskService {
    public  static final String JHS_KEY="jhs";
    public  static final String JHS_KEY_A="jhs:a";
    public  static final String JHS_KEY_B="jhs:b";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 偷个懒不加mybatis了，模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
     * @return
     */
    private List<Product> getProductsFromMysql() {
        List<Product> list=new ArrayList<>();
        for (int i = 1; i <=20; i++) {
            Random rand = new Random();
            int id= rand.nextInt(10000);
            Product obj=new Product((long) id,"product"+i,i,"detail");
            list.add(obj);
        }
        return list;
    }
 
    @PostConstruct
    public void initJHS() {
        log.info("启动定时器淘宝聚划算功能模拟.........."+ DateUtil.now());
        new Thread(() -> {
            //模拟定时器一个后台任务，定时把数据库的特价商品，刷新到redis中
            while (true){
                //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
                List<Product> list=this.getProductsFromMysql();
                //采用redis list数据结构的lpush来实现存储
                this.redisTemplate.delete(JHS_KEY);
                //lpush命令
                this.redisTemplate.opsForList().leftPushAll(JHS_KEY,list);
                //间隔一分钟 执行一遍，模拟聚划算每3天刷新一批次参加活动
                try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
 
                log.info("runJhs定时刷新..............");
            }
        },"t1").start();
    }
}
JHSProductController.java
package dev.matrixlab.redis7.controller;
 
import dev.matrixlab.redis7.entities.Product;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
@RestController
@Slf4j
@Api(tags = "聚划算商品列表接口")
public class JHSProductController {
    public  static final String JHS_KEY="jhs";
    public  static final String JHS_KEY_A="jhs:a";
    public  static final String JHS_KEY_B="jhs:b";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮
     * @param page
     * @param size
     * @return
     */
    @RequestMapping(value = "/pruduct/find",method = RequestMethod.GET)
    @ApiOperation("按照分页和每页显示容量，点击查看")
    public List<Product> find(int page, int size) {
        List<Product> list=null;
 
        long start = (page - 1) * size;
        long end = start + size - 1;
 
        try {
            //采用redis list数据结构的lrange命令实现分页查询
            list = this.redisTemplate.opsForList().range(JHS_KEY, start, end);
            if (CollectionUtils.isEmpty(list)) {
                //TODO 走DB查询
            }
            log.info("查询结果：{}", list);
        } catch (Exception ex) {
            //这里的异常，一般是redis瘫痪 ，或 redis网络timeout
            log.error("exception:", ex);
            //TODO 走DB查询
        }
 
        return list;
    }
}

  • Bug 和隐患说明

  • 热点 Key 突然消失导致缓存击穿

  • delete 命令执行的一瞬间有空隙，其他请求线程继续找 Redis 为 null

  • 打到 MySQL，暴击...

  • 复习

缓存问题产生原因解决方案
缓存更新方式数据变更、缓存时效性同步更新、失效更新、异步更新、定时更新
缓存不一致同步更新失败、异步更新增加重试、补偿任务、最终一致
缓存穿透恶意攻击空对象缓存、Bloom Filter
缓存击穿热点 Key 失效互斥更新、随机退避、差异失效时间
缓存雪崩缓存挂掉快速失败熔断、主从模式、集群模式
  • 最终目的是防止热 Key 突然失效暴击 MySQL

进一步升级加固案例

  • 互斥更新，采用双检加锁策略

  • 差异失效时间（双缓存架构）

  • 新建：开辟两块缓存，主从缓存，先更新从缓存再更新主缓存，严格按照整个顺序。

  • 查询：先查询主缓存，如果主缓存没有（消失或者失效了）再去查询从缓存。

JHSTaskService.java
package dev.matrixlab.redis7.service;
 
import cn.hutool.core.date.DateUtil;
import dev.matrixlab.redis7.entities.Product;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
 
@Service
@Slf4j
public class JHSTaskService {
    public  static final String JHS_KEY="jhs";
    public  static final String JHS_KEY_A="jhs:a";
    public  static final String JHS_KEY_B="jhs:b";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 偷个懒不加mybatis了，模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
    * @return
    */
    private List<Product> getProductsFromMysql() {
        List<Product> list=new ArrayList<>();
        for (int i = 1; i <=20; i++) {
            Random rand = new Random();
            int id= rand.nextInt(10000);
            Product obj=new Product((long) id,"product"+i,i,"detail");
            list.add(obj);
        }
        return list;
    }
 
    @PostConstruct
    public void initJHSAB() {
        log.info("启动AB定时器计划任务淘宝聚划算功能模拟.........."+DateUtil.now());
        new Thread(() -> {
            //模拟定时器，定时把数据库的特价商品，刷新到redis中
            while (true){
                //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
                List<Product> list=this.getProductsFromMysql();
                //先更新B缓存
                this.redisTemplate.delete(JHS_KEY_B);
                this.redisTemplate.opsForList().leftPushAll(JHS_KEY_B,list);
                this.redisTemplate.expire(JHS_KEY_B,20L,TimeUnit.DAYS);
                //再更新A缓存
                this.redisTemplate.delete(JHS_KEY_A);
                this.redisTemplate.opsForList().leftPushAll(JHS_KEY_A,list);
                this.redisTemplate.expire(JHS_KEY_A,15L,TimeUnit.DAYS);
                //间隔一分钟 执行一遍
                try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
 
                log.info("runJhs定时刷新双缓存AB两层..............");
            }
        },"t1").start();
    }
}
JHSProductController.java
package dev.matrixlab.redis7.controller;
 
import dev.matrixlab.redis7.entities.Product;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
@RestController
@Slf4j
@Api(tags = "聚划算商品列表接口")
public class JHSProductController {
    public  static final String JHS_KEY="jhs";
    public  static final String JHS_KEY_A="jhs:a";
    public  static final String JHS_KEY_B="jhs:b";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    @RequestMapping(value = "/pruduct/findab",method = RequestMethod.GET)
    @ApiOperation("防止热点key突然失效，AB双缓存架构")
    public List<Product> findAB(int page, int size) {
        List<Product> list=null;
        long start = (page - 1) * size;
        long end = start + size - 1;
        try {
            //采用redis list数据结构的lrange命令实现分页查询
            list = this.redisTemplate.opsForList().range(JHS_KEY_A, start, end);
            if (CollectionUtils.isEmpty(list)) {
                log.info("=========A缓存已经失效了，记得人工修补，B缓存自动延续5天");
                //用户先查询缓存A(上面的代码)，如果缓存A查询不到（例如，更新缓存的时候删除了），再查询缓存B
                this.redisTemplate.opsForList().range(JHS_KEY_B, start, end);
                //TODO 走DB查询
            }
            log.info("查询结果：{}", list);
        } catch (Exception ex) {
            //这里的异常，一般是redis瘫痪 ，或 redis网络timeout
            log.error("exception:", ex);
            //TODO 走DB查询
        }
        return list;
    }
}
缓存雪崩缓存穿透