Redis 缓存设计

最新推荐文章于 2023-12-14 16:12:56 发布

xiaocaodeshengri

最新推荐文章于 2023-12-14 16:12:56 发布

阅读量200

点赞数

分类专栏： redis

本文链接：https://blog.csdn.net/xiaocaodeshengri/article/details/109279472

版权

redis 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Redis 缓存设计

缓存设计

缓存穿透

缓存穿透是指查询一个根本不存在的数据，缓存层和存储层都不会命中，通常出于容错的考虑，如果从存储层查不到数据则不写入缓存层。

缓存穿透将导致不存在的数据每次请求都要到存储层去查询，失去了缓存保护后端存储的意义。

造成缓存穿透的基本原因有两个：

第一，自身业务代码或者数据出现问题。

第二，一些恶意攻击、爬虫等造成大量空命中。

缓存穿透问题解决方案：

1、缓存空对象

public class SaveEmpty {


    @Autowired
    private StringRedisTemplate cache;

    @Autowired
    private DataBaseDao storage;

    /**
     * 以下是一段伪代码
     * @param key
     * @return
     */

    public String  save(String key){

        // 从缓存中获取数据
        String cacheValue = cache.opsForValue().get(key);
        // 缓存为空
        if (StringUtils.isBlank(cacheValue)) {
            // 从存储中获取
            String storageValue = storage.get(key);
            cache.opsForValue().set(key, storageValue);
            // 如果存储数据为空， 需要设置一个过期时间(300秒)
            if (storageValue == null) {
                cache.expire(key, 60 * 5, TimeUnit.MINUTES);
            }
            return storageValue;
        } else {
            // 缓存非空
            return cacheValue;
        }
    }
}

2、布隆过滤器

对于恶意攻击，向服务器请求大量不存在的数据造成的缓存穿透，还可以用布隆过滤器先做一次过滤，对于不存在的数据布隆过滤器一般都能够过滤掉，不让请求再往后端发送。当布隆过滤器说某个值存在时，这个值可能不存在；当它说不存在时，那就肯定不存在。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OOwNs2jz-1603633409696)(E:\Program\tracy_cwh1229@163.com\6e00168381c14cee9b947d33e878e0cf\clipboard.png)]$

布隆过滤器就是一个大型的位数组和几个不一样的无偏 hash 函数。所谓无偏就是能够把元素的 hash 值算得比较均匀。

向布隆过滤器中添加 key 时，会使用多个 hash 函数对 key 进行 hash 算得一个整数索引值然后对位数组长度进行取模运算得到一个位置，每个 hash 函数都会算得一个不同的位置。再把位数组的这几个位置都置为 1 就完成了 add 操作。

向布隆过滤器询问 key 是否存在时，跟 add 一样，也会把 hash 的几个位置都算出来，看看位数组中这几个位置是否都为 1，只要有一个位为 0，那么说明布隆过滤器中这个key 不存在。如果都是 1，这并不能说明这个 key 就一定存在，只是极有可能存在，因为这些位被置为 1 可能是因为其它的 key 存在所致。如果这个位数组比较稀疏，这个概率就会很大，如果这个位数组比较拥挤，这个概率就会降低。

这种方法适用于数据命中不高、数据相对固定、实时性低（通常是数据集较大）的应用场景，代码维护较为复杂，但是缓存空间占用很少。

可以用guvua包自带的布隆过滤器，引入依赖：

<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>22.0</version>
        </dependency>

示例伪代码：

package com.example.redis.session.chuantou;
import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import io.micrometer.core.instrument.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;

public class BloomFilterTest {

    @Autowired
    private StringRedisTemplate cache;

    @Autowired
    private DataBaseDao storage;

    //初始化布隆过滤器
//1000：期望存入的数据个数，0.001：期望的误差率
    BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.forName("utf-8")), 1000, 0.001);

    private String[] keys;
    //把所有数据存入布隆过滤器
    void init(){
        for (String key: keys) {
            bloomFilter.put(key);
        }
    }

   public String get(String key) {
        // 从布隆过滤器这一级缓存判断下key是否存在
        Boolean exist = bloomFilter.mightContain(key);
        if(!exist){
            return "";
        }
        // 从缓存中获取数据
        String cacheValue = cache.opsForValue().get(key);
        // 缓存为空
        if (StringUtils.isBlank(cacheValue)) {
            // 从存储中获取
            String storageValue = storage.get(key);
            cache.opsForValue().set(key, storageValue);
            // 如果存储数据为空， 需要设置一个过期时间(300秒)
            if (storageValue == null) {
                cache.expire(key, 60 * 5, TimeUnit.MINUTES);
            }
            return storageValue;
        } else {
            // 缓存非空
            return cacheValue;
        }
    }
}

缓存失效

由于大批量缓存在同一时间失效可能导致大量请求同时穿透缓存直达数据库，可能会造成数据库瞬间压力过大甚至挂掉，对于这种情况我们在批量增加缓存时最好将这一批数据的缓存过期时间设置为一个时间段内的不同时间。

示例伪代码：

package com.example.redis.session.jichuan;

import com.example.redis.session.chuantou.DataBaseDao;
import io.micrometer.core.instrument.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Jichuan {

    @Autowired
    private StringRedisTemplate cache;

    @Autowired
    private DataBaseDao storage;

  public   String get(String key) {
        // 从缓存中获取数据
        String cacheValue = cache.opsForValue().get(key);
        // 缓存为空
        if (StringUtils.isBlank(cacheValue)) {
            // 从存储中获取
            String storageValue = storage.get(key);
            cache.opsForValue().set(key, storageValue);
            //设置一个过期时间(300到600之间的一个随机数)
            int expireTime = new Random().nextInt(300)  + 300;
            if (storageValue == null) {
                cache.expire(key, expireTime, TimeUnit.MINUTES);
            }
            return storageValue;
        } else {
            // 缓存非空
            return cacheValue;
        }
    }
}

缓存雪崩

缓存雪崩指的是缓存层支撑不住或宕掉后，流量会像奔逃的野牛一样，打向后端存储层。

由于缓存层承载着大量请求，有效地保护了存储层，但是如果缓存层由于某些原因不能提供服务(比如超大并发过来，缓存层支撑不住，或者由于缓存设计不好，类似大量请求访问bigkey，导致缓存能支撑的并发急剧下降)，于是大量请求都会达到存储层，存储层的调用量会暴增，造成存储层也会级联宕机的情况。

预防和解决缓存雪崩问题，可以从以下三个方面进行着手。

1）保证缓存层服务高可用性，比如使用Redis Sentinel或Redis Cluster。

2）依赖隔离组件为后端限流并降级。比如使用Hystrix限流降级组件。

3）提前演练。在项目上线前，演练缓存层宕掉后，应用以及后端的负载情况以及可能出现的问题，在此基础上做一些预案设定。

热点缓存key重建优化

开发人员使用“缓存+过期时间”的策略既可以加速数据读写，又保证数据的定期更新，这种模式基本能够满足绝大部分需求。但是有两个问题如果同时出现，可能就会对应用造成致命的危害：

当前key是一个热点key（例如一个热门的娱乐新闻），并发量非常大。
重建缓存不能在短时间完成，可能是一个复杂计算，例如复杂的SQL、多次IO、多个依赖等。

在缓存失效的瞬间，有大量线程来重建缓存，造成后端负载加大，甚至可能会让应用崩溃。

要解决这个问题主要就是要避免大量线程同时重建缓存。

我们可以利用互斥锁来解决，此方法只允许一个线程重建缓存，其他线程等待重建缓存的线程执行完，重新从缓存获取数据即可。

示例伪代码：

package com.example.redis.session.hot;

import com.example.redis.session.chuantou.DataBaseDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

public class HotPot {


    @Autowired
    private StringRedisTemplate cache;

    @Autowired
    private DataBaseDao storage;

    String get(String key) {
        // 从Redis中获取数据
        String value = cache.opsForValue().get(key);
        // 如果value为空， 则开始重构缓存
        if (value == null) {
            // 只允许一个线程重建缓存， 使用nx， 并设置过期时间ex
            String mutexKey = "mutext:key:" + key;
            String clientId = UUID.randomUUID().toString();
            if (cache.opsForValue().setIfAbsent(mutexKey, clientId, 30, TimeUnit.SECONDS)) {
                // 从数据源获取数据
                value = storage.get(key);
                // 回写Redis， 并设置过期时间
                long timeout =3 *60;
                cache.expire(key, timeout, TimeUnit.MINUTES);
                // 删除key_mutex
                cache.delete(mutexKey);
            }// 其他线程休息50毫秒后重试
            else {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                get(key);
            }
        }
        return value;
    }
}

xiaocaodeshengri

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis 缓存设计

Redis 缓存设计缓存设计缓存穿透缓存穿透是指查询一个根本不存在的数据，缓存层和存储层都不会命中，通常出于容错的考虑，如果从存储层查不到数据则不写入缓存层。缓存穿透将导致不存在的数据每次请求都要到存储层去查询，失去了缓存保护后端存储的意义。造成缓存穿透的基本原因有两个：第一，自身业务代码或者数据出现问题。第二，一些恶意攻击、爬虫等造成大量空命中。缓存穿透问题解决方案：1、缓存空对象public class SaveEmpty { @Autowired
复制链接

扫一扫