首页 > 数据库 >Redis三大缓存问题：缓存穿透、缓存击穿、缓存雪崩的场景以及解决方法

Redis三大缓存问题：缓存穿透、缓存击穿、缓存雪崩的场景以及解决方法

时间：2024-07-09 17:26:10浏览次数：24  
标签：缓存 String Redis key import data public 三大

文章目录

都是缓存惹的祸

在项目开发中，我们的数据都是要持久化到磁盘中去，比如使用 MySQL 进行持久化存储，但是呢由于流量越来越大，查询速度也逐渐变慢了起来，于是我们决定！使用缓存！然而使用缓存导致会经常面临三座大山！缓存穿透！！缓存击穿！！缓存雪崩！！
缓存穿透、缓存击穿和缓存雪崩是在使用缓存机制时可能遇到的问题，它们分别描述了不同的缓存失效场景，以及对系统性能的影响。下面将详细介绍这三种情况及其解决方法。

缓存穿透

缓存穿透

场景描述

缓存穿透通常发生在缓存和数据库间的数据一致性管理不当的情况下。例如，当用户请求一个不存在的数据项时，如果没有适当的处理机制，这个请求会直接穿透缓存层，直接落到数据库上。如果这种请求频繁发生，特别是在高并发环境下，数据库将面临巨大的压力，可能会导致服务响应变慢，甚至服务中断。

解决方法

解决缓存键同时失效和缓存中间件故障是维护分布式系统稳定性的重要方面。以下是针对这两种情况的详细解决方案及Java示例代码。

缓存键同时失效

1. 过期时间随机化

原理：
通过为每个缓存项设置一个随机的过期时间，避免大量缓存同时过期，减少数据库的瞬时压力。

Java示例代码：

假设我们使用Caffeine作为本地缓存库，以下是一个简单的实现：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.util.concurrent.TimeUnit;

public class CacheServiceWithRandomExpire {
    private final Cache<String, Object> cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .build();

    public synchronized Object getData(String key) {
        Object data = cache.getIfPresent(key);
        if (data != null) {
            return data;
        }
        
        data = fetchDataFromDB(key);
        if (data != null) {
            int expireTime = calculateRandomExpireTime();
            cache.put(key, data);
            cache.cleanUp(); // 清除过期项
            return data;
        }
        return null;
    }

    private Object fetchDataFromDB(String key) {
        // 模拟从数据库获取数据的过程
        System.out.println("Fetching data from DB for key: " + key);
        return "Data for key: " + key;
    }

    private int calculateRandomExpireTime() {
        int minExpireTime = 5; // 最小过期时间（分钟）
        int maxExpireTime = 10; // 最大过期时间（分钟）
        return (int) (Math.random() * (maxExpireTime - minExpireTime + 1)) + minExpireTime;
    }
}
2. 使用多级缓存

原理：
构建多级缓存体系，如本地缓存+远程缓存，利用本地缓存的高速度和远程缓存的大容量，分担请求压力，提高系统的稳定性和可用性。

Java示例代码：

假设我们使用Caffeine作为本地缓存库，Jedis作为远程Redis缓存库，以下是一个简单的实现：

import redis.clients.jedis.Jedis;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

public class MultiLevelCacheService {
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterAccess(5, TimeUnit.MINUTES)
            .build();

    private final Jedis jedis = new Jedis("localhost"); // 假设Redis运行在本地

    public synchronized Object getData(String key) {
        Object data = localCache.getIfPresent(key);
        if (data == null) {
            data = getFromRemoteCache(key);
            if (data == null) {
                data = fetchDataFromDB(key);
                if (data != null) {
                    localCache.put(key, data);
                    jedis.set(key, String.valueOf(data));
                }
            }
        }
        return data;
    }

    private Object getFromRemoteCache(String key) {
        String value = jedis.get(key);
        return value != null ? value : null;
    }

    private Object fetchDataFromDB(String key) {
        // 模拟从数据库获取数据的过程
        System.out.println("Fetching data from DB for key: " + key);
        return "Data for key: " + key;
    }
}
3. 缓存预热

原理：
缓存预热是指在系统启动或在预期的高峰访问时段之前，提前将热点数据加载到缓存中，以减少数据库的访问压力。这可以避免在系统启动初期或负载高峰期，因缓存未准备好而导致的数据库压力激增。

Java示例代码：

假设我们使用Caffeine作为本地缓存库，以下是一个简单的实现：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CacheWarmupService {
    private final Cache<String, Object> cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(5, java.util.concurrent.TimeUnit.MINUTES)
            .build();

    public CacheWarmupService() {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池
        executor.submit(this::warmUpCache); // 提交任务进行缓存预热
    }

    private void warmUpCache() {
        // 模拟加载热点数据到缓存
        for (String key : getHotKeys()) {
            Object data = fetchDataFromDB(key);
            if (data != null) {
                cache.put(key, data);
            }
        }
    }

    private Iterable<String> getHotKeys() {
        // 返回热点数据的key列表
        return List.of("hotKey1", "hotKey2", "hotKey3");
    }

    private Object fetchDataFromDB(String key) {
        // 模拟从数据库获取数据的过程
        System.out.println("Fetching data from DB for key: " + key);
        return "Data for key: " + key;
    }
}
4. 加互斥锁

原理：
在缓存失效时，为了避免多个请求同时重建缓存（缓存击穿），可以使用互斥锁（或分布式锁）来确保同一时间只有一个请求能够进入数据库获取数据并更新缓存，其他请求则等待锁释放后从缓存中获取数据。

Java示例代码：

假设我们使用ReentrantLock作为本地锁，以下是一个简单的实现：

import java.util.concurrent.locks.ReentrantLock;

public class CacheUpdateWithLock {
    private final Cache<String, Object> cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(5, java.util.concurrent.TimeUnit.MINUTES)
            .build();

    private final ReentrantLock lock = new ReentrantLock();

    public Object getData(String key) {
        Object data = cache.getIfPresent(key);
        if (data != null) {
            return data;
        }

        try {
            lock.lock(); // 获取锁
            data = fetchDataFromDB(key);
            if (data != null) {
                cache.put(key, data);
            }
        } finally {
            lock.unlock(); // 释放锁
        }

        return data;
    }

    private Object fetchDataFromDB(String key) {
        // 模拟从数据库获取数据的过程
        System.out.println("Fetching data from DB for key: " + key);
        return "Data for key: " + key;
    }
}

在分布式环境下，使用ReentrantLock可能不够，因为锁需要在多个节点之间共享。在这种情况下，可以使用分布式锁，如基于Redis的Redlock或Zookeeper的锁机制。

这些示例代码展示了如何在本地环境中实现缓存预热和加锁功能。在实际应用中，你可能需要根据你的具体需求和环境来调整代码，例如在分布式环境中使用分布式锁替代本地锁。

缓存中间件故障

1. 服务熔断 - Java示例

原理：
当检测到缓存中间件故障时，暂时停止业务逻辑，直接返回错误或默认值，避免系统整体崩溃。

Java示例代码：

这里使用Resilience4j库中的CircuitBreaker来实现服务熔断：

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;

public class CircuitBreakerDemo {
    private static final CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
    private static final CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("cacheService");

    public static void main(String[] args) {
        try {
            String result = circuitBreaker.executeSupplier(() -> {
                // 调用缓存服务
                return "Data fetched successfully";
            });

            System.out.println(result);
        } catch (Exception e) {
            System.out.println("Error occurred: " + e.getMessage());
        }
    }
}

在实际应用中，你需要根据你的具体业务需求调整这些示例代码，以适应你的系统架构和缓存策略。
构建Redis集群以提高高可用性和扩展性是分布式系统设计中的关键策略之一。Redis集群支持数据分区和自动故障转移，可以有效提高系统的稳定性和响应速度。以下是如何使用Java操作Redis集群的示例。

2. 构建Redis集群

原理
Redis集群通过在多个Redis实例之间分配数据槽（slot）来实现数据的分布存储。每个实例负责一部分槽，当数据插入或查询时，根据散列算法确定数据应存储在哪个槽，进而定位到正确的实例。

Java示例代码

为了连接和操作Redis集群，我们通常使用客户端库如JedisCluster或lettuce。下面使用JedisCluster库演示如何连接和操作Redis集群。

首先，你需要在你的项目中添加Jedis依赖。如果你使用Maven，可以添加如下依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.10.2</version>
</dependency>

接下来，我们将创建一个JedisCluster实例来连接Redis集群：

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import java.util.HashSet;
import java.util.Set;

public class RedisClusterDemo {
    public static void main(String[] args) {
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("node1-host", 7000)); // 替换为你的集群节点地址
        nodes.add(new HostAndPort("node2-host", 7001));
        nodes.add(new HostAndPort("node3-host", 7002));

        JedisCluster jedisCluster = new JedisCluster(nodes);
        
        // 使用JedisCluster执行操作
        jedisCluster.set("key", "value");
        String value = jedisCluster.get("key");
        System.out.println(value);
        
        // 关闭连接
        jedisCluster.close();
    }
}

在上述代码中，我们首先定义了一个包含集群节点的Set。然后，我们使用这些节点创建了一个JedisCluster实例。通过JedisCluster，你可以像操作单个Redis实例一样执行命令，但实际上是将命令发送给集群中的适当节点。

注意事项

  1. 故障转移：Redis集群支持自动故障转移。如果主节点失败，集群会自动选举一个新的主节点，但这个过程可能会影响短暂的服务可用性。
  2. 数据分布：确保理解数据是如何在集群中分布的，以及如何通过键来确定数据的位置。
  3. 配置和监控：配置Redis集群时，需要仔细设置集群参数，并且应该定期监控集群的健康状况。

在生产环境中，你可能还需要考虑集群的规模、节点的冗余、网络延迟等因素，以确保集群的高效和稳定运行。此外，为了更好地管理和监控集群，可以使用如Redis Commander、RedisInsight等工具。

注意事项

  1. **空值缓存的过期时间：**设置空值缓存时，过期时间不宜太长，以免占用过多的缓存资源。同时，过期时间也不能太短，否则频繁的请求仍可能造成数据库压力。
  2. **布隆过滤器的误判率：**布隆过滤器存在一定的误判率，这意味着某些不存在的key可能会被误认为存在。设计时需考虑误判对业务的影响，并可能需要结合其他机制（如二次确认）来降低误判的影响

缓存击穿

缓存击穿

场景描述

缓存击穿是指针对某一热点数据的大量请求导致缓存失效，进而直接请求数据库，增加数据库负载。这种情况通常发生在某个特定的缓存 key 在失效时，恰好有大量请求到达。想象一下大家都在抢茅台，但在某一时刻茅台的缓存失效了，大家的请求打到了数据库中，这就是缓存击穿，那他跟缓存雪崩有什么区别呢？缓存雪崩是多个 key 同时，缓存击穿是某个热点 key 崩溃。也可以认为缓存击穿是缓存雪崩的子集。

解决方法

为了解决这个问题，我们可以采取以下两种策略：

1. 加互斥锁（Mutex Lock）

原理
保证同一时间只有一个请求去数据库获取数据并更新缓存，其他请求则等待锁释放后从缓存中读取数据。

这里我们使用ReentrantLock作为本地锁的例子，但在分布式系统中，应当使用分布式锁，例如基于Redis的RedLock或其他分布式协调服务提供的锁。

Java示例代码

import java.util.concurrent.locks.ReentrantLock;
import redis.clients.jedis.Jedis;

public class CacheBusterSolution {
    private final Jedis jedis = new Jedis("localhost"); // 假设Redis运行在本地
    private final ReentrantLock lock = new ReentrantLock();

    public String getData(String key) {
        String data = jedis.get(key);
        if (data == null) {
            lock.lock();
            try {
                // 再次检查数据，因为在上锁期间可能已经有其他线程更新了缓存
                data = jedis.get(key);
                if (data == null) {
                    data = fetchFromDatabase(key);
                    jedis.set(key, data); // 将数据写入缓存
                }
            } finally {
                lock.unlock();
            }
        }
        return data;
    }

    private String fetchFromDatabase(String key) {
        // 模拟从数据库获取数据
        System.out.println("Fetching data from database for key: " + key);
        return "Data for key: " + key;
    }
}

注意事项

  • 使用互斥锁时，在分布式环境中应当使用分布式锁，否则锁的可见性和原子性无法得到保证。

2. 永久缓存热点数据

原理
对于热点数据，可以不设置过期时间，这样只要数据不被显式地删除或替换，就一直存在于缓存中，避免了过期问题。

Java示例代码

import redis.clients.jedis.Jedis;

public class HotDataPermanentCache {
    private final Jedis jedis = new Jedis("localhost"); // 假设Redis运行在本地

    public void cacheHotData(String key, String value) {
        jedis.set(key, value); // 不设置过期时间
    }

    public String getData(String key) {
        return jedis.get(key);
    }
}

注意事项

  • 永久缓存热点数据需要谨慎，因为这可能会导致缓存中的数据永远不更新，除非你有机制去检查并更新数据。
  • 在高并发场景下，即使使用了锁，也可能出现锁竞争激烈的情况，需要权衡锁的使用频率和锁的性能成本。

以上示例代码仅作演示之用，实际应用中需要根据具体情况进行调整和优化。例如，对于分布式锁的实现，可以考虑使用Redisson或JedisCluster等高级客户端库提供的功能。

注意事项

  1. 锁的粒度：使用互斥锁时，锁的粒度不宜太细，否则可能降低并发处理能力；粒度过粗可能导致锁等待时间过长，影响系统响应速度。
  2. 锁的实现：在分布式环境中，必须使用分布式锁，如RedLock或Etcd，以确保锁的正确性和一致性。
  3. 预热策略：缓存预热时要考虑到数据的时效性，避免预热的数据已经过期或不再热点

缓存雪崩

缓存雪崩
缓存穿透问题通常出现在缓存系统的设计中，当用户请求的数据既不在缓存中也不在数据库中时，这种情况会导致所有的请求都直接落到了数据库上，增加了数据库的负担，尤其是在高并发的情况下，可能会导致数据库服务的崩溃。

解决方案

1. 防止非法请求

原理
通过检查请求的有效性，如对请求的参数进行验证，对于疑似非法的请求，可以记录IP地址或用户ID，并在一段时间内对其进行封禁。

Java示例代码
使用Spring Security或其他框架进行请求的拦截和验证：

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DataController {

    @GetMapping("/data")
    @PreAuthorize("hasRole('USER')") // 示例权限检查
    public String getData(@RequestParam String key) {
        // 此处可以添加更多的参数验证逻辑
        return service.getData(key);
    }
}

2. 缓存空值

原理
当查询到数据库中不存在的数据时，将空值（如null或特定标识符）缓存起来，设置一个合理的过期时间，这样下次相同的查询就可以直接从缓存中返回，不再需要访问数据库。
使用Caffeine或Redis缓存空值：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.util.concurrent.TimeUnit;

public class CacheService {
    private final Cache<String, Object> cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(5, TimeUnit.MINUTES) // 设置空值过期时间为5分钟
            .build();

    public Object getData(String key) {
        return cache.get(key, k -> {
            Object data = fetchDataFromDB(k);
            if (data == null) {
                data = "NULL"; // 缓存空值
            }
            return data;
        });
    }

    private Object fetchDataFromDB(String key) {
        // 数据库查询逻辑
        return null;
    }
}

Java示例代码

3. 使用布隆过滤器

原理
布隆过滤器是一种空间效率极高的概率型数据结构，可以用来判断一个元素是否在一个集合中。虽然可能存在一定的误判率，但对于缓存穿透问题，它可以有效地过滤掉不存在的数据请求，避免它们直接到达数据库。

Java示例代码
使用Guava库中的BloomFilter：

import com.google.common.hash.Funnels;
import com.google.common.hash.BloomFilter;

import java.nio.charset.StandardCharsets;

public class BloomFilterDemo {
    private static final BloomFilter<CharSequence> bloomFilter = BloomFilter.create(Funnels.stringFunnel(StandardCharsets.UTF_8), 100000, 0.001);

    public static boolean mightExist(String key) {
        // 添加已知存在的key到布隆过滤器
        bloomFilter.put("existingKey");
        // 检查key是否可能存在
        return bloomFilter.mightContain(key);
    }
}

在实际应用中，你可以在缓存层先使用布隆过滤器检查数据是否存在，如果布隆过滤器返回false，则说明数据一定不存在，无需查询数据库；如果返回true，则需要进一步查询缓存或数据库以确认数据的存在。

请根据实际情况调整示例代码，以满足你的具体需求和环境。

注意事项

  1. **过期时间的设定：**过期时间的随机化策略需要合理设置范围，避免极端情况下的数据集中过期。
  2. 多级缓存架构：使用多级缓存时，需要平衡各级缓存的容量和过期策略，以达到最佳的性能和资源利用率。
  3. **限流策略：**在实施限流时，需要考虑到用户体验，避免过度限流导致正常用户的请求也无法及时响应。
  4. 监控与告警：无论哪种策略，都需要有实时的监控和告警机制，以便在出现问题时能够迅速定位并解决。
  5. 测试与验证：任何缓存策略的更改都应该经过充分的测试，包括单元测试、集成测试以及压力测试，确保在高并发情况下系统依然稳定。
  6. **数据一致性：**在设计缓存策略时，要特别注意数据的一致性问题，避免因缓存更新机制不当导致的数据不一致。
  7. **容灾与恢复：**设计缓存系统时，还应该考虑到灾难恢复计划，包括数据备份、快速切换至备用缓存服务器等措施。

参考：https://www.code-nav.cn/post/1780838173472006145#heading-0

标签：缓存,String,Redis,key,import,data,public,三大
From： https://blog.csdn.net/weixin_68020300/article/details/140272671

相关文章

  • Tomcat “缓存”清理
    一、关于Tomcat“缓存”的介绍很多时候大家喜欢把tomcat的work目录里的东西叫做缓存，其实那不是很恰当，work目录只是tomcat的工作目录，也就是tomcat把jsp转换为class文件的工作目录，这也正是为什么它叫work目录而不是cache目录的原因。jsp，tomcat的工作原理是当浏览器访问某个jsp......
  • redis常用命令
    redis常用命令:    1）连接操作命令   quit：关闭连接（connection）   auth：简单密码认证   helpcmd：查看cmd帮助，例如：helpquit      2）持久化   save：将数据同步保存到磁盘   bgsave：将数据异步保存到磁盘   lastsave：返回上次成功将数据保......
  • redis安装教程
    1.redis下载： Windows下载reids:https://github.com/MSOpenTech/redis/releases。 下载redis的可视化工具：https://github.com/uglide/RedisDesktopManager/releases/download/0.9.3/redis-desktop-manager-0.9.3.817.exe 2.启动redis:，，打开运行窗口,启动redis服务器端，然......
  • redis安装
    redis安装#1、安装编译环境等dnfinstall-ygccvimwget#2、下载并建立目录mkdirsoftwarewgethttps://download.redis.io/releases/redis-7.2.5.tar.gztar-zxvfredis-7.2.5.tar.gz#3、安装cdredis-7.2.5.tar.gzmakemakeinstall4、编译后默认安装目录是/usr/local/bin......
  • Redis复制过程详解
    主从复制简介  主从复制是为了达成高可用，即使有其中一台服务器宕机，其他服务器依然可以继续提供服务，实现Redis的高可用。  一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。 主从复制的作用  读写分离：主节点写，从节点读，提高服务器的读写负载能......
  • Redis数据类型与实现结构
    Redis提供了多种数据类型，每种数据类型都有其独特的实现结构和使用场景。以下是Redis中常见的数据类型及其底层实现结构：字符串（String）字符串是最基本的数据类型，可以存储二进制安全的字符串、整数或浮点数。实现结构：Redis使用 SDS（SimpleDynamicString）结构来存储字符串，这......
  • 【Redis 理论与实践学习】 一、Redis的数据结构：4.Set类型
    文章目录简介Set和List的区别常用命令增删改查类命令添加元素移除元素判断元素是否存在获取集合大小获取集合所有成员随机获取元素随机移除并返回元素运算操作命令集合间操作集合间操作并存储应用场景博客点赞用户点赞操作公众号共同关注用户关注集合共同关注查询......
  • redis学习笔记
    redis笔记1.Redis是什么？Redis（RemoteDictionaryServer）是一个使用C语言编写的，高性能非关系型的键值对数据库。与传统数据库不同的是，Redis的数据是存在内存中的，所以读写速度非常快，被广泛应用于缓存方向。Redis可以将数据写入磁盘中，保证了数据的安全不丢失，而且Redis的操作......
  • Redis事务
    001-redis事务 （1）Redis事务的概念： Redis事务的本质是一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。 总结说：redis事务就是......
  • Redis安全
    Redis安全一、账号密码端口安全1）账号密码安全。configgetrequiespass检查是否设置有密码，设置密码：CONFIGsetrequirepass"runoob"配置文件:#requirepassfoobared2）网络配置配置文件：bind192.168.1.100 #Redis服务器只监听本地网络接口，只有本机可以访问Redis服务器......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99