Bootstrap

Redis缓存判断热点数据及进行数据预热的几种方式介绍

Redis缓存如何判断热点数据？

热点数据计算整体来讲就是基于访问频率，可以是整体的访问次数，可以是一定时间内的频率，可以是部分请求的采样，可以借助成熟工具等，要根据业务需求来定

1. 基于访问频率

  • 原理：通过统计每个键的访问频率（如每秒访问次数），识别出访问频率最高的数据。
  • 实现方法：
    • 使用 Redis 的 INCR 命令或监控工具（如 Redis Monitor）统计键的访问频率。
      统计访问频率要确保并发场景下数据操作的一致性
    • 使用 Lua 脚本或客户端代码记录每个键的访问次数。

Java 实现

import redis.clients.jedis.Jedis;

public class HotKeyDetector {
    private Jedis jedis;

    public HotKeyDetector(Jedis jedis) {
        this.jedis = jedis;
    }

    public void trackAccess(String key) {
        // 使用 Redis 的计数器记录每个键的访问次数
        jedis.incr("access_count:" + key);
    }

    public String getMostFrequentKey() {
        // 获取所有键的访问计数
        Set<String> keys = jedis.keys("access_count:*");
        String hotKey = null;
        long maxCount = 0;

        for (String key : keys) {
            long count = Long.parseLong(jedis.get(key));
            if (count > maxCount) {
                maxCount = count;
                hotKey = key.replace("access_count:", "");
            }
        }

        return hotKey;
    }
}

2. 基于时间窗口

  • 原理：在特定的时间窗口内（如最近 1 分钟）统计键的访问频率，识别出热点数据。
  • 实现方法：
    • 使用 Redis 的 ZSET（有序集合）记录每个键的访问时间戳。
    • 定期清理过期的访问记录，并统计时间窗口内的访问次数。

Java 实现

import redis.clients.jedis.Jedis;

public class TimeWindowHotKeyDetector {
    private Jedis jedis;
    private static final long WINDOW_SIZE = 60000; // 时间窗口大小（1 分钟）

    public TimeWindowHotKeyDetector(Jedis jedis) {
        this.jedis = jedis;
    }

    public void trackAccess(String key) {
        long currentTime = System.currentTimeMillis();
        // 使用 ZSET 记录访问时间戳
        jedis.zadd("access_times:" + key, currentTime, String.valueOf(currentTime));
        // 清理时间窗口之外的数据
        jedis.zremrangeByScore("access_times:" + key, 0, currentTime - WINDOW_SIZE);
    }

    public String getMostFrequentKey() {
        Set<String> keys = jedis.keys("access_times:*");
        String hotKey = null;
        long maxCount = 0;

        for (String key : keys) {
            long count = jedis.zcard(key);
            if (count > maxCount) {
                maxCount = count;
                hotKey = key.replace("access_times:", "");
            }
        }

        return hotKey;
    }
}

3. 基于采样统计

  • 原理：通过采样部分请求，统计键的访问频率，推断出热点数据。
  • 实现方法：
    • 使用 Redis 的 MONITOR 命令或客户端代码采样请求。
    • 对采样数据进行分析，识别出高频访问的键。

4. 使用 Redis 模块（如 RedisGears）

  • 原理：利用 RedisGears 这样的扩展模块，实时监控和分析键的访问模式。
  • 实现方法：
    • 编写 RedisGears 脚本，统计键的访问频率并输出热点数据。

5. 基于外部监控工具

  • 原理：使用外部监控工具（如 Prometheus、Grafana）收集 Redis 的访问数据，并通过可视化或分析工具识别热点数据。
  • 实现方法：
    • 配置 Redis 的监控插件，将访问数据导出到监控工具。
    • 在监控工具中设置告警规则或分析报告。

总结

判断 Redis 分布式缓存中的热点数据可以通过以下方法：

  1. 基于访问频率：统计每个键的访问次数。
  2. 基于时间窗口：统计特定时间窗口内的访问频率。
  3. 基于采样统计：通过采样请求推断热点数据。
  4. 使用 Redis 模块：如 RedisGears 实时监控。
  5. 基于外部监控工具：如 Prometheus、Grafana。

Redis缓存如何进行数据预热？

数据预热是指在系统启动或流量高峰到来之前，提前将热点数据加载到缓存中，以避免大量请求直接访问数据库，从而提升系统性能和稳定性。

1. 手动预热

人为指定热key，将数据加载到缓存中

  • 原理：在系统启动或流量高峰前，通过脚本或工具手动将热点数据加载到 Redis 中。
  • 优点：简单直接，适合数据量较小或热点数据明确的场景。
  • 缺点：需要人工干预，无法自动化。

Java 实现

import redis.clients.jedis.Jedis;

public class DataPreheating {
    private Jedis jedis;

    public DataPreheating(Jedis jedis) {
        this.jedis = jedis;
    }

    public void preheatData() {
        // 模拟从数据库加载热点数据
        String[] hotKeys = {"key1", "key2", "key3"};
        for (String key : hotKeys) {
            String value = loadFromDatabase(key);
            jedis.set(key, value);
        }
    }

    private String loadFromDatabase(String key) {
        // 模拟数据库查询
        return "value_for_" + key;
    }
}

2. 基于历史访问记录的预热

系统自动读取热key，不需要人为指定

  • 原理：根据历史访问记录（如日志或监控数据），识别出热点数据，并在系统启动时加载到 Redis 中。
  • 优点：基于实际访问数据，预热效果较好。
  • 缺点：需要收集和分析历史数据，实现复杂度较高。

Java 实现

import redis.clients.jedis.Jedis;
import java.util.List;

public class HistoricalDataPreheating {
    private Jedis jedis;

    public HistoricalDataPreheating(Jedis jedis) {
        this.jedis = jedis;
    }

    public void preheatData() {
        // 从历史访问记录中获取热点数据
        List<String> hotKeys = getHotKeysFromLogs();
        for (String key : hotKeys) {
            String value = loadFromDatabase(key);
            jedis.set(key, value);
        }
    }

    private List<String> getHotKeysFromLogs() {
        // 模拟从日志中分析热点数据
        return List.of("key1", "key2", "key3");
    }

    private String loadFromDatabase(String key) {
        // 模拟数据库查询
        return "value_for_" + key;
    }
}

3. 基于定时任务的预热

定期自动加载热点数据，热点数据可通过访问频率，时间范围等自动计算

  • 原理：通过定时任务（如 Cron Job 或 Quartz）定期将热点数据加载到 Redis 中。
  • 优点：自动化程度高，适合数据变化较频繁的场景。
  • 缺点：需要配置定时任务，可能增加系统复杂性。

Java 实现

import redis.clients.jedis.Jedis;
import java.util.Timer;
import java.util.TimerTask;

public class ScheduledDataPreheating {
    private Jedis jedis;

    public ScheduledDataPreheating(Jedis jedis) {
        this.jedis = jedis;
    }

    public void startPreheating() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                preheatData();
            }
        }, 0, 60 * 60 * 1000); // 每小时执行一次
    }

    private void preheatData() {
        // 模拟从数据库加载热点数据
        String[] hotKeys = {"key1", "key2", "key3"};
        for (String key : hotKeys) {
            String value = loadFromDatabase(key);
            jedis.set(key, value);
        }
    }

    private String loadFromDatabase(String key) {
        // 模拟数据库查询
        return "value_for_" + key;
    }
}

4. 基于消息队列的预热

详细方案可参考此篇： 数据库与缓存一致性方案

  • 原理：当数据库中的数据发生变化时，通过消息队列（如 Kafka、RabbitMQ）通知缓存系统更新数据。
  • 优点：实时性高，适合数据变化频繁的场景（如商品上架，提前将信息预热到缓存中）。
  • 缺点：需要引入消息队列组件，增加系统复杂性。

Java 实现

import redis.clients.jedis.Jedis;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class MessageQueuePreheating {
    private Jedis jedis;
    private BlockingQueue<String> messageQueue;

    public MessageQueuePreheating(Jedis jedis) {
        this.jedis = jedis;
        this.messageQueue = new LinkedBlockingQueue<>();
        startConsumer();
    }

    public void onDataChange(String key) {
        // 当数据库数据变化时，将 key 放入消息队列
        messageQueue.offer(key);
    }

    private void startConsumer() {
        new Thread(() -> {
            while (true) {
                try {
                    String key = messageQueue.take();
                    String value = loadFromDatabase(key);
                    jedis.set(key, value);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }

    private String loadFromDatabase(String key) {
        // 模拟数据库查询
        return "value_for_" + key;
    }
}

5. 基于缓存淘汰策略的预热

没淘汰的key默认为热点数据

  • 原理：通过 Redis 的缓存淘汰策略（如 LRU、LFU），在缓存中保留热点数据。
  • 优点：无需额外操作，Redis 自动管理热点数据。
  • 缺点：无法精确控制预热数据。
    LRU：利用双向链表，最近访问的放链表头部，最久未访问的放链表尾部，空间不足时删除尾部数据
    LFP：利用最小堆，访问频率最低的放在堆顶，空间不足时移除堆顶数据

配置 Redis 淘汰策略

在 Redis 配置文件中设置：

maxmemory-policy allkeys-lfu
  • allkeys-lfu：淘汰访问频率最低的键。
  • allkeys-lru：淘汰最近最少使用的键。

总结

Redis 分布式缓存的数据预热可以通过以下方法实现：

  1. 手动预热：适合数据量较小或热点数据明确的场景。
  2. 基于历史访问记录的预热：根据历史数据加载热点数据。
  3. 基于定时任务的预热：定期加载热点数据，适合数据变化频繁的场景。
  4. 基于消息队列的预热：实时更新缓存，适合数据变化频繁的场景。
  5. 基于缓存淘汰策略的预热：利用 Redis 的淘汰策略自动管理热点数据。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
c语言 tls单向认证 验证证书,使用wireshark观察SSL/TLS握手过程--双向认证/单向认证...
YOLOv11-ultralytics-8.3.67部分代码阅读笔记-augment.py (ಥ_ಥ)
【发现】国产007里面星爷挖子弹时看的电影~~~~
Spring Boot 中的 TransactionTemplate 是什么，如何使用
STM32学习【4】ARM汇编（够用）
精选网站大全（AI、期刊论文、学习资源、实用工具等）持续更新~
H3C技术考核
基于python机器学习的天气预测及可视化分析系统设计与实现，采用随机森林算法+pyecharts实现（源码+数据+模型）
Redis缓存技术（三）
K8S 部署 Web UI