JAVA Redis Key 过期引发热点问题？TTL 策略与延迟淘汰机制剖析

JAVA Redis Key 过期引发热点问题？TTL 策略与延迟淘汰机制剖析

大家好，今天我们来聊聊在使用 Redis 时经常会遇到的一个问题：Key 过期引发的热点问题，以及 Redis 是如何处理过期 Key 的，也就是 TTL 策略和延迟淘汰机制。我们会从问题的产生、原理分析、解决方案以及代码示例等多个方面进行深入探讨，希望能帮助大家更好地理解和应对这类问题。

1. 热点 Key 过期问题：背景与场景

Redis 作为高性能的缓存数据库，被广泛应用于各种互联网应用中。为了提高效率和降低存储成本，我们会给 Key 设置过期时间 (TTL)。看似简单的过期机制，在特定场景下却可能引发一些棘手的问题，其中一个就是热点 Key 过期问题。

1.1 什么是热点 Key？

热点 Key 指的是在短时间内被大量并发请求访问的 Key。例如，热门商品、热点新闻、秒杀活动等等，这些 Key 的访问频率远高于其他 Key。

1.2 热点 Key 过期问题：雪崩效应

当大量热点 Key 在同一时间过期时，会发生什么？

• 缓存穿透： 所有对这些 Key 的请求都会直接打到数据库上，因为 Redis 中已经没有这些 Key 了。
• 数据库压力骤增： 大量的请求同时涌入数据库，可能导致数据库负载过高，甚至崩溃。
• 服务雪崩： 数据库崩溃反过来会影响其他依赖数据库的服务，导致整个系统瘫痪，这就是所谓的“雪崩效应”。

1.3 案例分析：秒杀活动

想象一下一个秒杀活动的场景：

• 商品信息存储在 Redis 中，设置了 1 分钟的过期时间。
• 活动开始后，大量用户涌入，并发请求 Redis 获取商品信息。
• 1 分钟后，所有热点 Key 同时过期。
• 后续请求全部落到数据库，数据库不堪重负，最终导致服务崩溃。

1.4 为什么会发生？

问题的根源在于：

• 集中过期： 大量 Key 设置了相同的过期时间，导致它们在同一时刻过期。
• 高并发： 热点 Key 本身就承受着大量的并发请求。
• 缓存失效： 过期导致缓存失效，所有请求直接访问数据库。

2. Redis 的 TTL 策略：过期 Key 的处理机制

为了处理过期 Key，Redis 采用了以下几种策略：

• 被动删除（Lazy Expiration）： 当客户端访问某个 Key 时，Redis 会先检查该 Key 是否过期。如果过期，则删除该 Key，然后返回给客户端（或者不返回）。
• 主动删除（Active Expiration）： Redis 会定期（默认每秒 10 次）扫描一部分 Key，检查它们是否过期。如果过期，则删除这些 Key。

2.1 被动删除：

被动删除的优点是简单高效，只有在访问 Key 的时候才会进行过期检查。但缺点是，如果某个 Key 长期没有被访问，那么它会一直存在于 Redis 中，占用内存。

2.2 主动删除：

主动删除的优点是可以定期清理过期的 Key，释放内存。但缺点是会消耗 CPU 资源，尤其是在 Key 数量很多的情况下。

2.3 Redis 的过期删除算法

Redis 主动删除过期 Key 的算法是：

1. 从过期字典中随机选择 20 个 Key。
2. 检查这 20 个 Key 是否过期，删除过期的 Key。
3. 如果超过 25% 的 Key 已过期，则重复步骤 1 和 2。
4. 如果扫描时间超过 25 毫秒，则停止扫描。

这个算法的设计目标是：

• 尽可能快地删除过期的 Key。
• 避免过度消耗 CPU 资源。

2.4 源码分析（简化版）

为了更好地理解 Redis 的过期删除机制，我们来看一段简化的 Java 代码，模拟 Redis 的过期 Key 处理：

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class RedisSimulator {

    private Map<String, ValueWithExpiration> data = new HashMap<>();
    private Random random = new Random();
    private int activeExpireCycleMs = 25; // 默认 25ms
    private int expireScanCount = 20; // 每次扫描 20 个 Key

    // 存储带过期时间的值
    private static class ValueWithExpiration {
        Object value;
        long expireTime;

        public ValueWithExpiration(Object value, long expireTime) {
            this.value = value;
            this.expireTime = expireTime;
        }
    }

    // 设置 Key-Value，带过期时间
    public void set(String key, Object value, long ttlMs) {
        long expireTime = System.currentTimeMillis() + ttlMs;
        data.put(key, new ValueWithExpiration(value, expireTime));
    }

    // 获取 Key
    public Object get(String key) {
        ValueWithExpiration valueWithExpiration = data.get(key);
        if (valueWithExpiration == null) {
            return null;
        }

        // 被动删除
        if (isExpired(valueWithExpiration.expireTime)) {
            data.remove(key);
            return null; // Key 已过期
        }

        return valueWithExpiration.value;
    }

    // 判断是否过期
    private boolean isExpired(long expireTime) {
        return System.currentTimeMillis() > expireTime;
    }

    // 主动过期删除
    public void activeExpireCycle() {
        long startTime = System.currentTimeMillis();
        int expiredCount = 0;

        while (System.currentTimeMillis() - startTime < activeExpireCycleMs) {
            int scanned = 0;
            Set<String> keys = data.keySet();
            if (keys.isEmpty()) {
                break;
            }

            // 随机选择 Key
            String[] randomKeys = new String[Math.min(expireScanCount, keys.size())];
            int i = 0;
            for (String key : keys) {
                if (i < randomKeys.length) {
                    randomKeys[i++] = key;
                } else {
                    break;
                }
            }

            for (String key : randomKeys) {
                scanned++;
                ValueWithExpiration valueWithExpiration = data.get(key);
                if (valueWithExpiration != null && isExpired(valueWithExpiration.expireTime)) {
                    data.remove(key);
                    expiredCount++;
                }
            }

            // 如果超过 25% 的 Key 已过期，则重复扫描
            if (scanned > 0 && (double) expiredCount / scanned <= 0.25) {
                break; // 退出循环
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        RedisSimulator redis = new RedisSimulator();

        // 设置一些 Key，带过期时间
        redis.set("key1", "value1", 1000); // 1 秒后过期
        redis.set("key2", "value2", 2000); // 2 秒后过期
        redis.set("key3", "value3", 3000); // 3 秒后过期

        // 模拟访问 Key
        System.out.println("key1: " + redis.get("key1")); // 第一次访问，可能未过期
        Thread.sleep(1500); // 等待 1.5 秒
        System.out.println("key1: " + redis.get("key1")); // 再次访问，应该过期了

        // 主动过期删除
        redis.activeExpireCycle();

        System.out.println("key2: " + redis.get("key2"));
        Thread.sleep(1000);
        System.out.println("key2: " + redis.get("key2"));
    }
}

代码解释：

• ValueWithExpiration 类：用于存储 Key 对应的 Value 和过期时间。
• set() 方法：用于设置 Key-Value，带过期时间。
• get() 方法：用于获取 Key 的值，同时进行被动删除。
• isExpired() 方法：用于判断 Key 是否过期。
• activeExpireCycle() 方法：模拟 Redis 的主动过期删除过程。
• main() 方法：演示了如何使用 RedisSimulator 类。

注意： 这只是一个简化的模拟，真实的 Redis 代码要复杂得多。

3. 解决方案：应对热点 Key 过期问题

针对热点 Key 过期问题，我们可以采取以下几种解决方案：

3.1 避免集中过期：

• 添加随机过期时间： 在设置 Key 的过期时间时，添加一个小的随机数，避免大量 Key 在同一时刻过期。
• 例如： SET key value EX 60 + random(10) (假设 EX 60 表示 60 秒后过期，random(10) 表示 0-10 秒的随机数)。

3.2 增加缓存预热：

• 提前加载热点数据： 在活动开始前，提前将热点数据加载到 Redis 中，避免活动开始时大量请求直接访问数据库。
• 定时刷新： 定期刷新 Redis 中的热点数据，保证数据的有效性。

3.3 使用互斥锁：

• 防止缓存击穿： 当缓存失效时，使用互斥锁（Mutex）来限制只有一个线程可以访问数据库，并将结果写入缓存，其他线程等待缓存更新后再访问。
• 代码示例（Java + Redisson）：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.config.Config;
import java.util.concurrent.TimeUnit;

public class CacheWithMutex {

    private static Redisson redisson;

    static {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379"); // 替换为你的 Redis 地址
        redisson = (Redisson) Redisson.create(config);
    }

    public static Object getDataWithMutex(String key, DataProvider dataProvider) {
        Object value = getFromCache(key);
        if (value != null) {
            return value;
        }

        RLock lock = redisson.getLock("lock:" + key);
        try {
            // 尝试获取锁，最多等待 3 秒，获取锁后 10 秒自动释放
            boolean locked = lock.tryLock(3, 10, TimeUnit.SECONDS);
            if (locked) {
                try {
                    // 再次检查缓存，防止其他线程已经更新了缓存
                    value = getFromCache(key);
                    if (value != null) {
                        return value;
                    }

                    // 从数据库获取数据
                    value = dataProvider.getDataFromDB(key);

                    // 将数据写入缓存
                    if (value != null) {
                        setCache(key, value);
                    }
                } finally {
                    lock.unlock(); // 释放锁
                }
            } else {
                // 没有获取到锁，等待一段时间后重试
                Thread.sleep(100);
                return getDataWithMutex(key, dataProvider);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null; // 或者抛出异常
        }

        return value;
    }

    private static Object getFromCache(String key) {
        // 模拟从 Redis 获取数据
        // 实际应用中需要使用 Redis 客户端
        return null; // 替换为你的 Redis 获取逻辑
    }

    private static void setCache(String key, Object value) {
        // 模拟将数据写入 Redis
        // 实际应用中需要使用 Redis 客户端
        System.out.println("写入缓存: key=" + key + ", value=" + value);
    }

    // 数据提供者接口，用于从数据库获取数据
    interface DataProvider {
        Object getDataFromDB(String key);
    }

    public static void main(String[] args) {
        // 示例用法
        DataProvider dataProvider = key -> {
            // 模拟从数据库获取数据
            System.out.println("从数据库获取数据: key=" + key);
            return "data from db for " + key;
        };

        String key = "hot_key";
        Object data = CacheWithMutex.getDataWithMutex(key, dataProvider);
        System.out.println("获取到的数据: " + data);

        // 关闭 Redisson 客户端
        redisson.shutdown();
    }
}

代码解释：

• getDataWithMutex() 方法：用于获取数据，如果缓存中不存在，则使用互斥锁来防止缓存击穿。
• RLock：Redisson 提供的分布式锁。
• tryLock()：尝试获取锁，最多等待 3 秒，获取锁后 10 秒自动释放。
• DataProvider 接口：用于从数据库获取数据。

3.4 使用多级缓存：

• 本地缓存 + Redis 缓存： 在 Redis 缓存的基础上，增加一层本地缓存（例如 Guava Cache），可以进一步提高缓存命中率，降低 Redis 的压力。
• 代码示例（Java + Guava Cache）：

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.TimeUnit;

public class MultiLevelCache {

    private static Cache<String, Object> localCache = CacheBuilder.newBuilder()
            .maximumSize(1000) // 最大缓存数量
            .expireAfterWrite(5, TimeUnit.SECONDS) // 5 秒后过期
            .build();

    public static Object getData(String key, DataProvider dataProvider) {
        // 先从本地缓存获取
        Object value = localCache.getIfPresent(key);
        if (value != null) {
            return value;
        }

        // 再从 Redis 缓存获取
        value = getFromRedis(key);
        if (value != null) {
            // 将数据写入本地缓存
            localCache.put(key, value);
            return value;
        }

        // 从数据库获取数据
        value = dataProvider.getDataFromDB(key);

        // 将数据写入 Redis 缓存和本地缓存
        if (value != null) {
            setRedis(key, value);
            localCache.put(key, value);
        }

        return value;
    }

    private static Object getFromRedis(String key) {
        // 模拟从 Redis 获取数据
        // 实际应用中需要使用 Redis 客户端
        return null; // 替换为你的 Redis 获取逻辑
    }

    private static void setRedis(String key, Object value) {
        // 模拟将数据写入 Redis
        // 实际应用中需要使用 Redis 客户端
        System.out.println("写入 Redis 缓存: key=" + key + ", value=" + value);
    }

    // 数据提供者接口，用于从数据库获取数据
    interface DataProvider {
        Object getDataFromDB(String key);
    }

    public static void main(String[] args) {
        // 示例用法
        DataProvider dataProvider = key -> {
            // 模拟从数据库获取数据
            System.out.println("从数据库获取数据: key=" + key);
            return "data from db for " + key;
        };

        String key = "hot_key";
        Object data = MultiLevelCache.getData(key, dataProvider);
        System.out.println("获取到的数据: " + data);
    }
}

代码解释：

• localCache：Guava Cache 实例，用于存储本地缓存。
• getData() 方法：先从本地缓存获取数据，如果不存在，则从 Redis 缓存获取，如果 Redis 缓存也不存在，则从数据库获取。
• getFromRedis() 和 setRedis() 方法：模拟从 Redis 获取和写入数据。
• DataProvider 接口：用于从数据库获取数据。

3.5 使用 Canal 等工具监听数据库变更：

• 实时更新缓存： 通过 Canal 等工具监听数据库的变更，当数据库中的数据发生变化时，及时更新 Redis 缓存，保证数据的一致性。

3.6 监控与告警：

• 实时监控 Redis 的性能指标： 例如 CPU 使用率、内存使用率、QPS、命中率等等。
• 设置告警阈值： 当性能指标超过阈值时，及时发出告警，以便及时处理问题。

3.7 总结表格对比：

解决方案	优点	缺点	适用场景
添加随机过期时间	简单易行，可以有效避免大量 Key 在同一时刻过期。	无法完全避免过期时间冲突，只能降低概率。	适用于所有需要设置过期时间的 Key，特别是热点 Key。
增加缓存预热	可以提前将热点数据加载到 Redis 中，避免活动开始时大量请求直接访问数据库。	需要提前预测热点数据，并且需要定期刷新缓存，保证数据的有效性。	适用于可以提前预测热点数据的场景，例如秒杀活动、热门商品等等。
使用互斥锁	可以有效防止缓存击穿，保证只有一个线程可以访问数据库。	会降低并发性能，因为其他线程需要等待锁释放。	适用于对数据一致性要求较高的场景，例如金融交易、订单处理等等。
使用多级缓存	可以进一步提高缓存命中率，降低 Redis 的压力。	需要维护多级缓存的一致性，增加开发的复杂性。	适用于对性能要求极高的场景，例如高并发的 Web 应用。
监听数据库变更	可以实时更新缓存，保证数据的一致性。	增加系统的复杂性，需要引入额外的组件（例如 Canal）。	适用于对数据一致性要求极高的场景，并且需要实时更新缓存。
监控与告警	可以实时监控 Redis 的性能指标，及时发现问题并处理。	需要投入一定的资源进行监控系统的建设和维护。	适用于所有使用 Redis 的场景，可以帮助及时发现和解决问题。

4. 总结：应对热点 key 过期，多种策略组合使用

热点 Key 过期问题是使用 Redis 时需要重点关注的问题之一。通过了解 Redis 的 TTL 策略和过期删除机制，并结合实际场景选择合适的解决方案，可以有效地避免热点 Key 过期带来的负面影响。最佳实践往往是多种策略的组合使用，例如添加随机过期时间 + 互斥锁 + 多级缓存 + 监控告警。

5. 思考：延迟删除机制的进一步优化

除了上述策略，延迟删除机制本身也可以进行优化，例如：

• 更智能的扫描策略： 可以根据 Key 的访问频率来调整扫描的优先级，优先扫描访问频率高的 Key。
• 异步删除： 可以将过期 Key 的删除操作放入一个异步队列中，避免阻塞主线程。

希望今天的分享对大家有所帮助，谢谢！