redis 预热数据的策略 redis预热缓存

转载

mob64ca14137e4f 2023-10-18 16:01:17

文章标签 redis 预热数据的策略 redis 缓存数据库数据 文章分类 Redis 数据库

缓存预热

缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据！

缓存预热就是在 redis 启动的时候，就开始往 redis 中写了数据，然后再给应用提供服务。而不是在应用访问的时候才开始往 redis 中写数据。

那么启动的时候，应该往 redis 中写入什么样的数据呢？

应该根据当天的具体的访问情况，进行实时的统计出访问量频率较高的数据，即热数据，比如热门商品，热门博客等，把这部分数据提前写入 redis集群中。我们不需要把所有的数据都写入 redis中，也没有这个必要，一是数据量会很大，写入的数据会很慢，二是访问量不大的数据也没有必要写入 redis 中。
如果热数据比较多的话，我们可以启动多个服务并行读取数据去写入 redis 集群，进行分布式的缓存预热。
当把热数据写入 redis 集群后，才开始对处提供服务。那么这样，大部分的请求都会走 redis 集群，而不需要访问 mysql 数据库。

怎么解决？

首先，通过 nginx + lua 的方式，把访问流量数据上报到 Kafka，也可以是其它的 mq 队列。
然后使用实时计算框架(如 storm 、spark streaming、flume)从 kafka中消费访问流量数据，实时计算出访问频率高的数据，这里统计出来的可能只会有编号信息，如商品编号或博客编号等。
最后，根据编号从 mysql 数据库中查询出具体的信息，写入 redis，开始提供服务。

还有一种解决思路：

直接写个缓存刷新页面，上线时手工操作下。
数据量不大，可以在WEB系统启动的时候加载。
定时刷新缓存，

缓存雪崩

缓存雪崩现象：假设有如下一个系统，高峰期请求为5000次/秒，4000次走了缓存，只有1000次落到了数据库上，数据库每秒1000的并发是一个正常的指标，完全可以正常工作，但如果缓存宕机了，或者缓存设置了相同的过期时间，导致缓存在同一时刻同时失效，每秒5000次的请求会全部落到数据库上，数据库立马就死掉了，因为数据库一秒最多抗2000个请求，如果DBA重启数据库，立马又会被新的请求打死了，这就是缓存雪崩。

解决方法

1、事前：redis高可用，主从+哨兵，redis cluster，避免全盘崩溃
2、事中：本地ehcache缓存 + hystrix限流&降级，避免MySQL被打死
3、事后：redis持久化RDB+AOF，快速恢复缓存数据
4、缓存的失效时间设置为随机值，避免同时失效

缓存的失效时间设置为随机值
setRedis（key, value, time+Math.random()*10000）;

如果Redis是集群部署，将热点数据均匀分布在不同的Redis库中也能避免全部失效。或者设置热点数据永不过期，有更新操作就更新缓存就好了（比如运维更新了首页商品，那你刷下缓存就好了，不要设置过期时间），电商首页的数据也可以用这个操作，保险。

缓存击穿

缓存击穿就是单个高热数据过期的瞬间，数据访问量较大，未命中redis后，发起了大量对同一数据的数据库访问，导致对数据库服务器造成压力。应对策略应该在业务数据分析与预防方面进行，配合运行监控测试与即时调整策略，毕竟单个key的过期监控难度较高，配合雪崩处理策略即可。

缓存击穿和缓存雪崩很相似，缓存雪崩是针对所有的key，缓存击穿针对的是某一个key

场景，假如秒杀一个商品的key，但是这个key过期了，对这个商品的并发量过高。缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。

解决方案

1、设置热点数据永远不过期。
2、接口限流与熔断，降级。重要的接口一定要做好限流策略，防止用户恶意刷接口，同时要降级准备，当接口中的某些服务
不可用时候，进行熔断，失败快速返回机制。
3、布隆过滤器。bloomfilter就类似于一个hash set，用于快速判某个元素是否存在于集合中，其典型的应用场景就是快速判断一个key是否存在于某容器，不存在就直接返回。布隆过滤器的关键就在于hash算法和容器大小，
4、加互斥锁，互斥锁参考代码如下：

@Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private Jedis               jedis;
    private final String        MUTEX_KEY = "MUTEX_";

    public String getData(String key) throws InterruptedException {
        String value = stringRedisTemplate.opsForValue().get(key);
        //缓存失效
        if (StringUtils.isBlank(value)) {
            //设置分布式锁，只允许一个线程去查询DB，同时指定过期时间为1min，防止del操作失败，导致死锁，缓存过期无法加载DB数据
            if (tryLock(MUTEX_KEY + key, 60L)) {
                //从数据库查询数据,将查询的结果缓存起来
                value = getValueFromDB();
                stringRedisTemplate.opsForValue().set(key, value);

                //释放分布式锁
                stringRedisTemplate.delete(MUTEX_KEY + key);
            } else {
                //当锁被占用时，睡眠5s继续调用获取数据请求
                Thread.sleep(5000);
                getData(key);}
        }
        return value;
    }

    /**
     * redis实现分布式事务锁 尝试获取锁
     * 
     * @param lockName  锁
     * @param expireTime 过期时间
     * @return
     */
    public Boolean tryLock(String lockName, long expireTime) {
        //RedisCallback redis事务管理，将redis操作命令放到事务中处理，保证执行的原子性
        String result = stringRedisTemplate.opsForValue().getOperations().execute(new RedisCallback<String>() {

            /**
             * @param key 使用key来当锁，因为key是唯一的。
             * @param value 请求标识，可通过UUID.randomUUID().toString()生成,解锁时通value参数可识别出是哪个请求添加的锁
             * @param nx 表示SET IF NOT EXIST，即当key不存在时，我们进行set操作；若key已经存在，则不做任何操作
             * @param ex 表示过期时间的单位是秒
             * @param time 表示过期时间
             */
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                return jedis.set(lockName, UUID.randomUUID().toString(), "NX", "EX", expireTime);
            }
        });

        if ("OK".equals(result)) {
            return true;
        }
        return false;
    }

    public String getValueFromDB() {
        return "";
    }

缓存穿透

缓存穿透是指缓存和数据库中都没有的数据，而用户（黑客）不断发起请求，对系统进行恶意的攻击。
举个栗子：我们数据库的id都是从1自增的，如果发起id=-1的数据或者id特别大不存在的数据，这时的用户很可能是攻击者，这样的不断攻击导致数据库压力很大，严重会击垮数据库。

解决办法：
方法一：缓存穿透我会在接口层增加校验，比如用户鉴权，参数做校验，不合法的校验直接return，比如id做基础校验，id<=0直接拦截。
方法二：查询不到的数据也放到缓存，value为空，如 set -999 “”
方法三：Redis里还有一个高级用法布隆过滤器（Bloom Filter）`这个也能很好的预防缓存穿透的发生，他的原理也很简单，就是利用高效的数据结构和算法快速判断出你这个Key是否在数据库中存在，不存在你return就好了，存在你就去查DB刷新KV再return。

布隆过滤器（亿级数据过滤算法）

一、先抛出一个问题爬虫系统中URL是怎么判重的？
你可能最先想到的是将URL放到一个set中，但是当数据很多的时候，放在set中是不现实的。
这时你就可能想到用数组+hash函数来实现了。

index = hash(URL) % table.length

即求出URL的hash值对数组长度取模，得到数组的下标，然后设置table[index] = 1，当然数组刚开始的元素都为0

这样每次有新的URL来的时候，先求出index，然后看table[index]的值，当为0的时候，URL肯定不存在，当为1的时候URL可能存在，因为有可能发生hash冲突。即第一次
hash(www.baidu.com) % table.length = 1，table[1]=1，第二次hash(www.javashitang.com) % table.length = 1，此时table[1]=1，系统会认为www.javashitang.com已经爬取过了，其实并没有爬取。

从上面的流程中我们基本可以得出如下结论：hash冲突越少，误判率越低

二、怎么减少hash冲突呢？

1、增加数组长度
2、优化hash函数，使用多个hash函数来判断

多个hash函数求得数组位置的值都为1时才认为这个元素存在，只要有一个为0则认为这个元素不存在。在一定概率上能降低冲突的概率。
那么hash函数是不是越多越好呢？当然不是了，hash函数越多，数组中1的数量相应的也会增多，反而会增加冲突。所以hash函数不能太多也不能太少。

你可能没意识到布隆过滤器的原理你已经懂了，只不过布隆过滤器存0和1不是用数组，而是用位，我们来算一下申请一个 100w 个元素的位数组只占用 1000000Bit / 8 = 125000 Byte = 125000/1024 kb ≈ 122kb 的空间，是不是很划算？

三、来总结一下布隆过滤器的特点

1、布隆过滤器说某个元素存在，其实有可能不存在，因为hash冲突会导致误判
2、布隆过滤器说某个元素不存在则一定不存在

四、使用场景

1、判断指定数据在海量数据中是否存在，防止缓存穿透等
2、爬虫系统判断某个URL是否已经处理过

五、手写一个布隆过滤器

public class MyBloomFilter {

    // 位数组的大小
    private static final int DEFAULT_SIZE = 2 << 24;

    // hash函数的种子
    private static final int[] SEEDS = new int[]{3, 13, 46};

    // 位数组，数组中的元素只能是 0 或者 1
    private BitSet bits = new BitSet(DEFAULT_SIZE);

    // hash函数
    private SimpleHash[] func = new SimpleHash[SEEDS.length];

    public MyBloomFilter() {
        for (int i = 0; i < SEEDS.length; i++) {
            func[i] = new SimpleHash(DEFAULT_SIZE, SEEDS[i]);
        }
    }

    // 添加元素到位数组
    public void add(Object value) {
        for (SimpleHash f : func) {
            bits.set(f.hash(value), true);
        }
    }

    // 判断指定元素是否存在于位数组
    public boolean contains(Object value) {
        boolean ret = true;
        for (SimpleHash f : func) {
            ret = ret && bits.get(f.hash(value));
            // hash函数有一个计算出为false，则直接返回
            if (!ret) {
                return ret;
            }
        }
        return ret;
    }

    // hash函数类
    public static class SimpleHash {

        private int cap;
        private int seed;

        public SimpleHash(int cap, int seed) {
            this.cap = cap;
            this.seed = seed;
        }

        public int hash(Object value) {
            int h;
            return (value == null) ? 0 : Math.abs(seed * (cap - 1) & ((h = value.hashCode()) ^ (h >>> 16)));
        }

    }

    public static void main(String[] args) {
        Integer value1 = 13423;
        Integer value2 = 22131;
        MyBloomFilter filter = new MyBloomFilter();
        // false
        System.out.println(filter.contains(value1));
        // false
        System.out.println(filter.contains(value2));
        filter.add(value1);
        filter.add(value2);
        // true
        System.out.println(filter.contains(value1));
        // true
        System.out.println(filter.contains(value2));
    }
}

六、利用Google的Guava工具库实现布隆过滤器
生产环境中一般不用自己手写的布隆过滤器，用Google大牛写好的工具类即可。

1、加入如下依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>27.0.1-jre</version>
</dependency>

// 创建布隆过滤器对象，最多元素数量为500，期望误报概率为0.01
BloomFilter<Integer> filter = BloomFilter.create(
        Funnels.integerFunnel(), 500, 0.01);
// 判断指定元素是否存在
// false
System.out.println(filter.mightContain(1));
// false
System.out.println(filter.mightContain(2));
// 将元素添加进布隆过滤器
filter.put(1);
filter.put(2);
// true
System.out.println(filter.mightContain(1));
// true
System.out.println(filter.mightContain(2));

七、用Redis中的布隆过滤器
Redis4.0以插件的形式提供了布隆过滤器。来演示一波

使用docker安装并启动

docker pull redislabs/rebloom
docker run -itd --name redis -p:6379:6379 redislabs/rebloom
docker exec -it redis /bin/bash
redis-cli

常用的命令如下

# 添加元素  
bf.add
# 查看元素是否存在
bf.exists
# 批量添加元素
bf.madd
# 批量查询元素
bf.mexists
127.0.0.1:6379> bf.add test 1
(integer) 1
127.0.0.1:6379> bf.add test 2
(integer) 1
127.0.0.1:6379> bf.exists test 1
(integer) 1
127.0.0.1:6379> bf.exists test 3
(integer) 0
127.0.0.1:6379> bf.exists test 4
(integer) 0

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。