Apr 06 2022

Redis缓存穿透、击穿、雪崩终极解决方案：从布隆过滤器到多级缓存架构

作者： 绝缘体..   发布： 2022-04-06 17:42   分类： 未分类   阅读：   抢沙发  
 
更多

Redis缓存穿透、击穿、雪崩终极解决方案：从布隆过滤器到多级缓存架构

引言

在现代分布式系统中，Redis作为高性能的内存数据库，已成为缓存架构的核心组件。然而，在实际应用中，开发者常常会遇到缓存相关的三大核心问题：缓存穿透、缓存击穿和缓存雪崩。这些问题不仅会影响系统的性能，还可能导致服务不可用，严重影响用户体验。

本文将深入分析这三个问题的本质原因，并提供完整的解决方案体系。我们将从布隆过滤器预防缓存穿透、互斥锁防止缓存击穿、熔断降级应对缓存雪崩等多个维度，构建一套高可用的分布式缓存架构。通过理论分析结合实际代码示例，帮助读者掌握这些关键技术的最佳实践。

一、缓存问题概述

1.1 缓存穿透

缓存穿透是指查询一个根本不存在的数据。由于缓存中没有该数据，请求会直接打到数据库，而数据库中也不存在该数据，导致每次请求都需要访问数据库。这种情况在恶意攻击或数据冷启动时尤为常见。

1.2 缓存击穿

缓存击穿是指某个热点数据在缓存中过期，此时大量并发请求同时访问该数据，导致数据库瞬间压力过大。这种情况下，数据库可能因为瞬时高并发而崩溃。

1.3 缓存雪崩

缓存雪崩是指大量缓存数据在同一时间失效，导致所有请求都直接打到数据库，造成数据库压力过大甚至宕机。这种情况通常发生在缓存服务器大规模重启或配置错误时。

二、布隆过滤器防缓存穿透

2.1 布隆过滤器原理

布隆过滤器是一种概率型数据结构，用于快速判断一个元素是否存在于集合中。它通过多个哈希函数将元素映射到位数组中的多个位置，具有空间效率高、查询速度快的特点。

public class BloomFilter {
    private static final int DEFAULT_SIZE = 1 << 24; // 16M
    private static final int[] SEEDS = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
    
    private BitArray bitArray;
    private int[] hashFunctions;
    
    public BloomFilter() {
        this(DEFAULT_SIZE);
    }
    
    public BloomFilter(int size) {
        this.bitArray = new BitArray(size);
        this.hashFunctions = new int[SEEDS.length];
        for (int i = 0; i < SEEDS.length; i++) {
            this.hashFunctions[i] = SEEDS[i];
        }
    }
    
    public void add(String value) {
        if (value == null) return;
        for (int hash : hashFunctions) {
            int index = getHash(value, hash) % bitArray.size();
            bitArray.set(index);
        }
    }
    
    public boolean contains(String value) {
        if (value == null) return false;
        for (int hash : hashFunctions) {
            int index = getHash(value, hash) % bitArray.size();
            if (!bitArray.get(index)) {
                return false;
            }
        }
        return true;
    }
    
    private int getHash(String value, int seed) {
        int hash = 0;
        for (char c : value.toCharArray()) {
            hash = hash * seed + c;
        }
        return Math.abs(hash);
    }
}

class BitArray {
    private long[] array;
    private int size;
    
    public BitArray(int size) {
        this.size = size;
        this.array = new long[(size + 63) / 64];
    }
    
    public void set(int index) {
        int wordIndex = index / 64;
        int bitIndex = index % 64;
        array[wordIndex] |= (1L << bitIndex);
    }
    
    public boolean get(int index) {
        int wordIndex = index / 64;
        int bitIndex = index % 64;
        return (array[wordIndex] & (1L << bitIndex)) != 0;
    }
    
    public int size() {
        return size;
    }
}

2.2 在Redis中的应用

在Redis中使用布隆过滤器可以有效防止缓存穿透问题。通过预先将所有存在的key添加到布隆过滤器中，当查询不存在的数据时，可以直接拒绝，避免访问数据库。

@Component
public class CacheService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String BLOOM_FILTER_KEY = "bloom_filter";
    private static final String CACHE_PREFIX = "cache:";
    
    /**
     * 初始化布隆过滤器
     */
    public void initBloomFilter() {
        // 将已知的key添加到布隆过滤器中
        Set<String> existingKeys = getAllExistingKeys();
        for (String key : existingKeys) {
            redisTemplate.opsForValue().set(BLOOM_FILTER_KEY + ":" + key, "1");
        }
    }
    
    /**
     * 检查key是否存在并获取数据
     */
    public Object getData(String key) {
        // 先检查布隆过滤器
        if (!isKeyExistsInBloomFilter(key)) {
            return null; // 直接返回null，不查询数据库
        }
        
        // 查询缓存
        String cacheKey = CACHE_PREFIX + key;
        Object value = redisTemplate.opsForValue().get(cacheKey);
        
        if (value != null) {
            return value;
        }
        
        // 缓存未命中，查询数据库
        value = queryFromDatabase(key);
        if (value != null) {
            // 设置缓存，带过期时间
            redisTemplate.opsForValue().set(cacheKey, value, 300, TimeUnit.SECONDS);
        }
        return value;
    }
    
    /**
     * 使用布隆过滤器检查key是否存在
     */
    private boolean isKeyExistsInBloomFilter(String key) {
        try {
            // 这里可以集成第三方布隆过滤器库，如RedisBloom
            return redisTemplate.hasKey(BLOOM_FILTER_KEY + ":" + key);
        } catch (Exception e) {
            // 如果布隆过滤器不可用，降级处理
            return true;
        }
    }
    
    /**
     * 查询数据库
     */
    private Object queryFromDatabase(String key) {
        // 实际的数据库查询逻辑
        return null;
    }
    
    /**
     * 获取所有已存在的key
     */
    private Set<String> getAllExistingKeys() {
        // 实现获取所有已存在key的逻辑
        return new HashSet<>();
    }
}

三、互斥锁防缓存击穿

3.1 互斥锁机制原理

当缓存失效时，使用互斥锁确保同一时间只有一个线程去查询数据库，其他线程等待结果。这样可以有效防止缓存击穿问题。

@Component
public class CacheWithMutex {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String LOCK_PREFIX = "lock:";
    private static final String CACHE_PREFIX = "cache:";
    
    /**
     * 带互斥锁的缓存获取方法
     */
    public Object getDataWithMutex(String key) {
        String cacheKey = CACHE_PREFIX + key;
        String lockKey = LOCK_PREFIX + key;
        
        // 先尝试从缓存获取
        Object value = redisTemplate.opsForValue().get(cacheKey);
        if (value != null) {
            return value;
        }
        
        // 尝试获取分布式锁
        boolean lockSuccess = acquireLock(lockKey, key, 5000);
        if (lockSuccess) {
            try {
                // 再次检查缓存，防止重复查询
                value = redisTemplate.opsForValue().get(cacheKey);
                if (value != null) {
                    return value;
                }
                
                // 查询数据库
                value = queryFromDatabase(key);
                if (value != null) {
                    // 设置缓存
                    redisTemplate.opsForValue().set(cacheKey, value, 300, TimeUnit.SECONDS);
                }
                
                return value;
            } finally {
                // 释放锁
                releaseLock(lockKey, key);
            }
        } else {
            // 获取锁失败，等待一段时间后重试
            try {
                Thread.sleep(100);
                return getDataWithMutex(key);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return null;
            }
        }
    }
    
    /**
     * 获取分布式锁
     */
    private boolean acquireLock(String lockKey, String requestId, long expireTime) {
        String script = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then " +
                      "redis.call('pexpire', KEYS[1], ARGV[2]) return 1 else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), 
                                          requestId, String.valueOf(expireTime));
        return result != null && result == 1;
    }
    
    /**
     * 释放分布式锁
     */
    private void releaseLock(String lockKey, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                      "return redis.call('del', KEYS[1]) else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        redisTemplate.execute(redisScript, Collections.singletonList(lockKey), requestId);
    }
    
    /**
     * 查询数据库
     */
    private Object queryFromDatabase(String key) {
        // 实际的数据库查询逻辑
        return null;
    }
}

3.2 优化版本的互斥锁实现

为了提高性能，可以使用更智能的锁策略，比如设置锁的超时时间，避免死锁问题。

@Component
public class OptimizedCacheWithMutex {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String LOCK_PREFIX = "lock:";
    private static final String CACHE_PREFIX = "cache:";
    private static final long DEFAULT_LOCK_EXPIRE = 5000; // 5秒
    private static final long DEFAULT_CACHE_EXPIRE = 300; // 5分钟
    
    public Object getDataWithOptimizedMutex(String key) {
        String cacheKey = CACHE_PREFIX + key;
        String lockKey = LOCK_PREFIX + key;
        
        // 先尝试从缓存获取
        Object value = redisTemplate.opsForValue().get(cacheKey);
        if (value != null) {
            return value;
        }
        
        // 尝试获取锁，设置超时时间
        String lockValue = UUID.randomUUID().toString();
        boolean lockSuccess = acquireLock(lockKey, lockValue, DEFAULT_LOCK_EXPIRE);
        
        if (lockSuccess) {
            try {
                // 双重检查缓存
                value = redisTemplate.opsForValue().get(cacheKey);
                if (value != null) {
                    return value;
                }
                
                // 查询数据库
                value = queryFromDatabase(key);
                if (value != null) {
                    // 设置缓存，使用较短的过期时间
                    redisTemplate.opsForValue().set(cacheKey, value, DEFAULT_CACHE_EXPIRE, TimeUnit.SECONDS);
                }
                
                return value;
            } finally {
                // 安全释放锁
                releaseLock(lockKey, lockValue);
            }
        } else {
            // 等待一段时间后重试
            return waitForAndRetry(key);
        }
    }
    
    private boolean acquireLock(String lockKey, String lockValue, long expireTime) {
        // 使用SET命令的NX和EX参数实现原子性操作
        String result = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, 
                                                              Duration.ofMillis(expireTime));
        return result != null && result;
    }
    
    private void releaseLock(String lockKey, String lockValue) {
        // 使用Lua脚本确保原子性
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                      "return redis.call('del', KEYS[1]) else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        redisTemplate.execute(redisScript, Collections.singletonList(lockKey), lockValue);
    }
    
    private Object waitForAndRetry(String key) {
        try {
            Thread.sleep(50);
            return getDataWithOptimizedMutex(key);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        }
    }
    
    private Object queryFromDatabase(String key) {
        // 实际的数据库查询逻辑
        return null;
    }
}

四、熔断降级防缓存雪崩

4.1 熔断器模式

熔断器模式是解决缓存雪崩的重要手段。当检测到系统压力过大时，自动切换到降级模式，返回默认值或空值，保护后端服务。

@Component
public class CircuitBreakerService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String CIRCUIT_BREAKER_KEY = "circuit_breaker:";
    private static final String DEFAULT_VALUE = "default_value";
    
    // 熔断器状态
    enum CircuitState {
        CLOSED, // 关闭状态 - 正常运行
        OPEN,   // 开启状态 - 熔断
        HALF_OPEN // 半开状态 - 尝试恢复
    }
    
    /**
     * 带熔断器的缓存获取方法
     */
    public Object getDataWithCircuitBreaker(String key) {
        String circuitKey = CIRCUIT_BREAKER_KEY + key;
        CircuitState state = getCircuitState(circuitKey);
        
        switch (state) {
            case OPEN:
                // 熔断状态下，返回默认值
                return getDefaultOrEmptyValue(key);
            case HALF_OPEN:
                // 半开状态下，允许部分请求通过
                if (allowRequestThrough()) {
                    return getDataWithFallback(key);
                } else {
                    return getDefaultOrEmptyValue(key);
                }
            case CLOSED:
            default:
                // 正常状态下，正常处理
                return getDataWithFallback(key);
        }
    }
    
    /**
     * 获取熔断器状态
     */
    private CircuitState getCircuitState(String circuitKey) {
        String stateStr = (String) redisTemplate.opsForValue().get(circuitKey + ":state");
        if (stateStr == null) {
            return CircuitState.CLOSED;
        }
        
        return CircuitState.valueOf(stateStr);
    }
    
    /**
     * 获取数据并处理熔断逻辑
     */
    private Object getDataWithFallback(String key) {
        try {
            // 先尝试从缓存获取
            Object value = redisTemplate.opsForValue().get("cache:" + key);
            if (value != null) {
                return value;
            }
            
            // 缓存未命中，查询数据库
            value = queryFromDatabase(key);
            if (value != null) {
                redisTemplate.opsForValue().set("cache:" + key, value, 300, TimeUnit.SECONDS);
            }
            
            // 重置熔断器状态
            resetCircuitBreaker(key);
            return value;
            
        } catch (Exception e) {
            // 发生异常，触发熔断
            triggerCircuitBreaker(key);
            return getDefaultOrEmptyValue(key);
        }
    }
    
    /**
     * 触发熔断
     */
    private void triggerCircuitBreaker(String key) {
        String circuitKey = CIRCUIT_BREAKER_KEY + key;
        redisTemplate.opsForValue().set(circuitKey + ":state", CircuitState.OPEN.name());
        redisTemplate.expire(circuitKey + ":state", 30, TimeUnit.SECONDS); // 30秒后尝试恢复
        
        // 记录错误次数
        String errorCountKey = circuitKey + ":error_count";
        Long currentCount = redisTemplate.opsForValue().increment(errorCountKey, 1);
        redisTemplate.expire(errorCountKey, 60, TimeUnit.SECONDS); // 1分钟内统计
        
        // 如果错误次数过多，延长熔断时间
        if (currentCount != null && currentCount > 5) {
            redisTemplate.expire(circuitKey + ":state", 60, TimeUnit.SECONDS);
        }
    }
    
    /**
     * 重置熔断器
     */
    private void resetCircuitBreaker(String key) {
        String circuitKey = CIRCUIT_BREAKER_KEY + key;
        redisTemplate.delete(circuitKey + ":state");
        redisTemplate.delete(circuitKey + ":error_count");
    }
    
    /**
     * 判断是否允许请求通过
     */
    private boolean allowRequestThrough() {
        // 实现随机策略或其他逻辑
        return Math.random() > 0.5;
    }
    
    /**
     * 获取默认值
     */
    private Object getDefaultOrEmptyValue(String key) {
        // 返回默认值或空值
        return DEFAULT_VALUE;
    }
    
    private Object queryFromDatabase(String key) {
        // 实际的数据库查询逻辑
        return null;
    }
}

4.2 多级缓存架构

构建多级缓存架构是防止缓存雪崩的根本解决方案。通过在不同层级设置缓存，即使某一层失效，其他层仍能提供服务。

@Component
public class MultiLevelCacheService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 不同级别的缓存配置
    private static final String LOCAL_CACHE_KEY = "local_cache:";
    private static final String REDIS_CACHE_KEY = "redis_cache:";
    private static final String DATABASE_KEY = "database:";
    
    // 本地缓存大小
    private final LoadingCache<String, Object> localCache = 
        Caffeine.newBuilder()
               .maximumSize(1000)
               .expireAfterWrite(300, TimeUnit.SECONDS)
               .build(this::loadFromRedis);
    
    /**
     * 多级缓存获取数据
     */
    public Object getDataMultiLevel(String key) {
        try {
            // 1. 首先查询本地缓存
            Object localValue = localCache.getIfPresent(key);
            if (localValue != null) {
                return localValue;
            }
            
            // 2. 查询Redis缓存
            Object redisValue = getFromRedis(key);
            if (redisValue != null) {
                // 同步到本地缓存
                localCache.put(key, redisValue);
                return redisValue;
            }
            
            // 3. 查询数据库
            Object dbValue = queryFromDatabase(key);
            if (dbValue != null) {
                // 同步到Redis和本地缓存
                putToRedis(key, dbValue);
                localCache.put(key, dbValue);
            }
            
            return dbValue;
            
        } catch (Exception e) {
            // 出现异常时，返回默认值
            return getDefaultData(key);
        }
    }
    
    /**
     * 从Redis获取数据
     */
    private Object getFromRedis(String key) {
        return redisTemplate.opsForValue().get(REDIS_CACHE_KEY + key);
    }
    
    /**
     * 向Redis存储数据
     */
    private void putToRedis(String key, Object value) {
        redisTemplate.opsForValue().set(REDIS_CACHE_KEY + key, value, 300, TimeUnit.SECONDS);
    }
    
    /**
     * 从Redis加载数据到本地缓存
     */
    private Object loadFromRedis(String key) {
        return getFromRedis(key);
    }
    
    /**
     * 查询数据库
     */
    private Object queryFromDatabase(String key) {
        // 实际的数据库查询逻辑
        return null;
    }
    
    /**
     * 获取默认数据
     */
    private Object getDefaultData(String key) {
        return "default_" + key;
    }
    
    /**
     * 清除指定缓存
     */
    public void clearCache(String key) {
        localCache.invalidate(key);
        redisTemplate.delete(REDIS_CACHE_KEY + key);
    }
    
    /**
     * 批量清除缓存
     */
    public void clearAllCache() {
        localCache.invalidateAll();
        // 清除Redis中的所有缓存（谨慎使用）
    }
}

五、综合解决方案设计

5.1 完整的缓存管理类

@Component
public class ComprehensiveCacheManager {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private BloomFilter bloomFilter;
    
    private static final String CACHE_PREFIX = "cache:";
    private static final String LOCK_PREFIX = "lock:";
    private static final String CIRCUIT_BREAKER_PREFIX = "circuit:";
    
    /**
     * 综合缓存获取方法
     */
    public Object getDataComprehensive(String key) {
        // 1. 布隆过滤器检查
        if (!checkWithBloomFilter(key)) {
            return null;
        }
        
        // 2. 获取缓存数据
        Object value = getFromCache(key);
        if (value != null) {
            return value;
        }
        
        // 3. 获取分布式锁
        String lockKey = LOCK_PREFIX + key;
        String lockValue = UUID.randomUUID().toString();
        boolean lockAcquired = acquireLock(lockKey, lockValue, 5000);
        
        if (lockAcquired) {
            try {
                // 双重检查缓存
                value = getFromCache(key);
                if (value != null) {
                    return value;
                }
                
                // 查询数据库
                value = queryFromDatabase(key);
                if (value != null) {
                    // 设置缓存
                    setToCache(key, value);
                }
                
                return value;
            } finally {
                releaseLock(lockKey, lockValue);
            }
        } else {
            // 等待后重试
            return waitForRetry(key);
        }
    }
    
    /**
     * 布隆过滤器检查
     */
    private boolean checkWithBloomFilter(String key) {
        // 实现布隆过滤器检查逻辑
        return bloomFilter.contains(key);
    }
    
    /**
     * 从缓存获取数据
     */
    private Object getFromCache(String key) {
        return redisTemplate.opsForValue().get(CACHE_PREFIX + key);
    }
    
    /**
     * 设置缓存数据
     */
    private void setToCache(String key, Object value) {
        redisTemplate.opsForValue().set(CACHE_PREFIX + key, value, 300, TimeUnit.SECONDS);
    }
    
    /**
     * 获取分布式锁
     */
    private boolean acquireLock(String lockKey, String lockValue, long expireTime) {
        String script = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then " +
                      "redis.call('pexpire', KEYS[1], ARGV[2]) return 1 else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), 
                                          lockValue, String.valueOf(expireTime));
        return result != null && result == 1;
    }
    
    /**
     * 释放分布式锁
     */
    private void releaseLock(String lockKey, String lockValue) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                      "return redis.call('del', KEYS[1]) else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        redisTemplate.execute(redisScript, Collections.singletonList(lockKey), lockValue);
    }
    
    /**
     * 等待后重试
     */
    private Object waitForRetry(String key) {
        try {
            Thread.sleep(100);
            return getDataComprehensive(key);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        }
    }
    
    /**
     * 查询数据库
     */
    private Object queryFromDatabase(String key) {
        // 实际的数据库查询逻辑
        return null;
    }
}

5.2 性能监控和告警

@Component
public class CacheMonitor {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String MONITOR_KEY = "cache_monitor:";
    
    /**
     * 记录缓存命中率
     */
    public void recordHitRate(String cacheName, boolean hit) {
        String key = MONITOR_KEY + cacheName + ":hit_rate";
        if (hit) {
            redisTemplate.opsForValue().increment(key + ":hit", 1);
        } else {
            redisTemplate.opsForValue().increment(key + ":miss", 1);
        }
        
        // 更新时间戳
        redisTemplate.opsForValue().set(key + ":last_update", System.currentTimeMillis());
    }
    
    /**
     * 获取缓存统计信息
     */
    public Map<String, Object> getCacheStats(String cacheName) {
        Map<String, Object> stats = new HashMap<>();
        String key = MONITOR_KEY + cacheName + ":";
        
        // 获取命中次数
        Long hitCount = (Long) redisTemplate.opsForValue().get(key + "hit");
        // 获取未命中次数
        Long missCount = (Long) redisTemplate.opsForValue().get(key + "miss");
        // 获取最后更新时间
        Long lastUpdate = (Long) redisTemplate.opsForValue().get(key + "last_update");
        
        stats.put("hit_count", hitCount != null ? hitCount : 0);
        stats.put("miss_count", missCount != null ? missCount : 0);
        stats.put("last_update", lastUpdate != null ? lastUpdate : 0);
        
        if (hitCount != null && missCount != null) {
            long total = hitCount + missCount;
            if (total > 0) {
                double hitRate = (double) hitCount / total;
                stats.put("hit_rate", String.format("%.2f%%", hitRate * 100));
            }
        }
        
        return stats;
    }
    
    /**
     * 告警检查
     */
    public void checkAlerts() {
        // 检查缓存命中率是否过低
        // 检查缓存穿透率
        // 检查缓存击穿情况
        // 发送告警通知
    }
}

六、最佳实践和注意事项

6.1 配置优化建议

  1. 缓存过期时间设置：合理设置缓存过期时间，避免长时间缓存导致数据不一致
  2. 布隆过滤器大小：根据业务数据量预估合适的布隆过滤器大小
  3. 锁超时时间：设置合理的锁超时时间，避免死锁
  4. 重试机制：实现合理的重试机制，避免无限重试

6.2 性能调优

@Configuration
public class CacheConfig {
    
    @Bean
    public

本文来自极简博客，作者：魔法星河，转载请注明原文链接：Redis缓存穿透、击穿、雪崩终极解决方案：从布隆过滤器到多级缓存架构

打赏

本文固定链接: https://www.cxy163.net/archives/7052 | 绝缘体

该日志由 绝缘体.. 于 2022年04月06日 发表在 未分类 分类下， 你可以发表评论，并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: Redis缓存穿透、击穿、雪崩终极解决方案：从布隆过滤器到多级缓存架构 | 绝缘体
关键字: , , , ,
【上一篇】
【下一篇】

您可能还会对这些文章感兴趣！

  1. CVE-2022-0543
  2. docker进阶_dockerswarm
  3. docker进阶_docker-compose
  4. docker基础_网络模式
  5. 命令行清空memcache缓存的两种方法
  6. laravel 缓存系统的使用
  7. (转载)Go channel 的妙用
  8. MariaDB/MySQL配置文件my.cnf解读
  9. 如何在 Laravel 代码中正确地使用数据库事务
  10. Redis的集群模式和数据分片方案
  11. 整理常用Laravel5帮助函数四（其他帮助函数）
  12. jquery表单缓存插件formcache
  13. Redis 7.0多线程性能优化实战：从单线程到多线程
  14. Node.js高并发服务性能优化实战：从事件循环到集
  15. Docker容器化应用性能调优：从基础镜像优化到资源
  16. Redis缓存穿透、击穿、雪崩解决方案：从布隆过滤

Redis缓存穿透、击穿、雪崩终极解决方案：从布隆过滤器到多级缓存架构：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter