Java缓存案例如何基础实现

wen java案例 2026-07-01 21

Java缓存案例如何基础实现：从零构建高效缓存系统

目录导读

缓存的核心价值与应用场景
Java缓存基础实现方案
案例实战：手写一个简单缓存
缓存策略与性能优化
常见问题与Q&A
总结与扩展建议

缓存的核心价值与应用场景

在Java企业级应用中,缓存是提升系统性能最直接有效的技术手段，根据Google搜索引擎排名算法，网站加载速度每慢1秒，转化率下降7%；而合理使用缓存能将数据访问延迟从毫秒级降至微秒级。

Java缓存案例如何基础实现

典型场景：

高频读取、低频更新的数据（如商品分类、配置信息）
数据库查询结果复用（如热门文章列表）
计算密集型结果缓存（如报表统计结果）

面试高频问题：
Q：为什么不用数据库直接查询，而要引入缓存？
A：数据库的IO瓶颈和连接池压力是主要限制，假设每秒10000次查询请求，数据库只能处理2000次/秒（视硬件），缓存（如内存）可轻松处理100万+次/秒，缓存避免了重复计算，显著降低响应时间。

Java缓存基础实现方案

1 内存级缓存 vs 分布式缓存

特性	本地缓存（如HashMap）	分布式缓存（如Redis）
数据容量	受JVM堆内存限制	可横向扩展
一致性	单机强一致	需考虑网络分区
适用场景	单机应用、小规模数据	集群部署、跨服务共享

2 最简实现：HashMap

public class SimpleCache<K, V> {
    private final Map<K, V> cache = new ConcurrentHashMap<>();
    public V get(K key) {
        return cache.get(key);
    }
    public void put(K key, V value) {
        cache.put(key, value);
    }
}

问题：永不过期、内存泄漏风险、无淘汰策略。

3 进阶：带过期时间的缓存

使用DelayQueue或ScheduledExecutorService实现定时清理，但更好的选择是使用成熟框架如Guava Cache或Caffeine。

案例实战：手写一个简单缓存

1 需求分析

实现一个支持自动过期、最大容量限制、LRU淘汰策略的缓存。

2 核心代码实现

public class LruCache<K, V> {
    private final int maxCapacity;
    private final Map<K, CacheNode<K, V>> map;
    private final CacheNode<K, V> head, tail; // 双向链表头尾
    public LruCache(int maxCapacity) {
        this.maxCapacity = maxCapacity;
        this.map = new LinkedHashMap<>(maxCapacity, 0.75f, true);
        this.head = new CacheNode<>(null, null);
        this.tail = new CacheNode<>(null, null);
        head.next = tail;
        tail.prev = head;
    }
    public V get(K key) {
        CacheNode<K, V> node = map.get(key);
        if (node == null) return null;
        moveToHead(node); // 最近使用移到头部
        return node.value;
    }
    public void put(K key, V value) {
        CacheNode<K, V> node = map.get(key);
        if (node != null) {
            node.value = value;
            moveToHead(node);
        } else {
            node = new CacheNode<>(key, value);
            map.put(key, node);
            addToHead(node);
            if (map.size() > maxCapacity) {
                removeTail(); // 移除最久未使用
            }
        }
    }
    // 双向链表操作省略，核心逻辑：moveToHead、addToHead、removeTail
}

3 测试案例

public class CacheTest {
    public static void main(String[] args) {
        LruCache<String, String> cache = new LruCache<>(3);
        cache.put("A", "val1");
        cache.put("B", "val2");
        cache.put("C", "val3");
        cache.get("A"); // 访问A，使A成为最近使用
        cache.put("D", "val4"); // 此时应淘汰B
        System.out.println(cache.get("B")); // 输出null
    }
}

缓存策略与性能优化

1 淘汰策略选择

策略	原理	适用场景
FIFO	先入先出	强时效性数据（如限时活动）
LRU	最近最少使用	热点数据明显（如用户会话）
LFU	最不经常使用	访问频率差异大（如商品详情）

2 缓存穿透/雪崩/击穿

缓存穿透：查询不存在的数据 → 布隆过滤器或缓存空值
缓存雪崩：大量缓存同时过期 → 随机过期时间+二级缓存
缓存击穿：热点key过期 + 高并发 → 互斥锁或分布式锁

实战代码：防止缓存穿透

public V getWithBloom(K key, CacheLoader<K, V> loader) {
    if (!bloomFilter.mightContain(key)) return null; // 不存在直接返回
    V value = cache.get(key);
    if (value == null) {
        synchronized (this) { // 加锁防止击穿
            value = cache.get(key);
            if (value == null) {
                value = loader.load(key);
                if (value == null) {
                    cache.put(key, (V) NULL_PLACEHOLDER); // 缓存空对象
                } else {
                    cache.put(key, value);
                }
            }
        }
    }
    return value == NULL_PLACEHOLDER ? null : value;
}