Java缓存技术：JCache容量驱逐策略详解与实践

1. JCache与驱逐策略基础概念解析

JCache（JSR-107）作为Java标准化的缓存API，其驱逐策略（Eviction Policy）是面试中高频出现的核心考点。理解驱逐策略的本质需要先明确几个关键概念：

缓存驱逐的本质：当缓存达到容量上限时，系统需要按照特定算法移除部分条目以腾出空间。这个过程就像图书馆书架满了之后，管理员需要决定哪些旧书该下架一样。JCache规范定义了多种驱逐策略，其中基于容量的驱逐（Capacity-based Eviction）是最基础且最常用的方式。

JSR-107规范中的关键接口：

java复制javax.cache.configuration.Configuration<K, V>
javax.cache.configuration.MutableConfiguration<K, V>

这些接口提供了驱逐策略的配置入口。实际开发中我们通常使用MutableConfiguration进行灵活配置，其setEvictionConfig()方法正是设置驱逐策略的关键。

容量驱逐的典型场景：

• 电商平台商品详情缓存（防止热门商品被冷门商品挤出）
• 秒杀系统的库存缓存（需要严格控制内存占用）
• 实时风控系统的规则缓存（保证最新规则优先保留）

注意：JCache规范只定义了API行为，具体实现由各缓存提供商（如Ehcache、Hazelcast等）完成。这意味着不同实现可能在细节上有差异，但核心逻辑保持一致。

2. 容量驱逐策略的配置方法

2.1 基础配置示例

下面是一个完整的配置示例，展示如何创建一个使用容量驱逐策略的缓存：

java复制import javax.cache.Cache;
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.MutableConfiguration;
import javax.cache.spi.CachingProvider;

public class CacheConfigDemo {
    public static void main(String[] args) {
        // 获取缓存提供者（这里以默认实现为例）
        CachingProvider provider = Caching.getCachingProvider();
        CacheManager cacheManager = provider.getCacheManager();
        
        // 创建可变的配置对象
        MutableConfiguration<String, String> config = new MutableConfiguration<>();
        
        // 设置键值类型
        config.setTypes(String.class, String.class);
        
        // 配置容量驱逐策略：最大1000个条目，淘汰最近最少使用的
        config.setEvictionConfig(
            EvictionConfiguration.builder()
                .setMaxSize(1000)
                .setEvictionPolicy(EvictionPolicy.LRU)
                .build()
        );
        
        // 创建缓存实例
        Cache<String, String> myCache = cacheManager.createCache("myCache", config);
    }
}

2.2 关键参数详解

maxSize：

• 定义缓存能保存的最大条目数
• 达到该数值时触发驱逐
• 建议根据业务需求和硬件资源设置
• 典型值范围：几百到几十万不等

evictionPolicy：

2.3 不同缓存实现的差异

虽然JCache提供了标准API，但不同实现可能有额外配置项：

Ehcache示例：

java复制CacheConfigurationBuilder.newCacheConfigurationBuilder(
    String.class, 
    String.class,
    ResourcePoolsBuilder.newResourcePoolsBuilder()
        .heap(1000, EntryUnit.ENTRIES)  // 明确指定基于条目数的堆内存
).withEvictionAdvisor(new MyCustomEvictionAdvisor())  // 可添加自定义驱逐建议器

Hazelcast特殊配置：

xml复制<hazelcast>
    <cache name="myCache">
        <eviction size="1000" max-size-policy="ENTRY_COUNT" eviction-policy="LRU"/>
        <expiry-policy-factory>
            <timed-expiry-policy-factory
                expiry-policy-type="CREATED"
                duration-amount="1"
                time-unit="MINUTES"/>
        </expiry-policy-factory>
    </cache>
</hazelcast>

3. 容量驱逐的底层实现原理

3.1 常见算法实现对比

LRU的典型实现：

java复制// 简化版的LinkedHashMap实现
public class LRUCache<K,V> extends LinkedHashMap<K,V> {
    private final int maxSize;
    
    public LRUCache(int maxSize) {
        super(maxSize, 0.75f, true);
        this.maxSize = maxSize;
    }
    
    @Override
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return size() > maxSize;
    }
}

LFU的优化实现：
现代缓存系统通常使用更高效的LFU变种，如TinyLFU：

1. 使用Count-Min Sketch统计频率
2. 定期采样窗口重置计数
3. 结合LRU处理频率相同的情况

3.2 驱逐触发时机

驱逐并非在达到maxSize时才发生，而是有以下几种触发方式：

1. 主动驱逐：

   • 显式调用cache.invalidate(key)
   • 批量清除cache.clear()

2. 被动驱逐：

   • 新条目插入导致容量超限
   • 后台线程定期扫描（某些实现）

3. 混合模式：

   java复制// Hazelcast的异步驱逐配置示例
   config.setEvictionConfig(new EvictionConfig()
       .setSize(1000)
       .setEvictionPolicy(EvictionPolicy.LRU)
       .setExpiryPolicyFactory(AccessedExpiryPolicy.factoryOf(Duration.ONE_MINUTE))
   );
   

3.3 内存占用计算

容量驱逐虽然按条目数计算，但实际内存占用需要考虑：

• 键对象大小
• 值对象大小
• 缓存数据结构开销
• JVM对象头开销

估算公式：

code复制总内存 ≈ 条目数 × (平均键大小 + 平均值大小 + 100字节 overhead)

实战技巧：对于大对象缓存，建议使用软引用/弱引用配置，防止OOM：

java复制config.setStoreByValue(false);  // 启用引用存储

4. 生产环境中的最佳实践

4.1 容量规划建议

根据业务特性选择合适容量：

读多写少型：

• 容量设为QPS的5-10倍
• 使用LRU策略
• 示例：商品详情缓存

读写均衡型：

• 容量设为并发请求量的2-3倍
• 考虑LFU策略
• 示例：用户会话缓存

突发流量型：

• 设置动态扩容机制
• 结合TTL使用
• 示例：秒杀库存缓存

4.2 监控与调优

关键监控指标：

示例监控代码：

java复制CacheStatistics stats = cache.getStatistics();
System.out.println("命中率: " + stats.getCacheHitPercentage());
System.out.println("驱逐次数: " + stats.getEvictions());

4.3 常见问题排查

问题1：驱逐过于频繁

• 现象：命中率骤降，缓存效果差
• 排查步骤：
  1. 检查当前容量配置
  2. 分析访问模式是否变化
  3. 考虑改用LFU策略
  4. 增加容量或引入多级缓存

问题2：内存溢出

• 现象：OOM异常，服务崩溃
• 解决方案：

  java复制// 启用软引用+容量限制双重保护
  config.setEvictionConfig(...);
  config.setStoreByValue(false);
  config.setStatisticsEnabled(true);
  

问题3：性能下降

• 现象：缓存操作延迟增加
• 优化方向：
  • 检查驱逐算法时间复杂度
  • 考虑分片缓存
  • 评估并发级别设置

5. 高级特性与扩展应用

5.1 自定义驱逐策略

通过实现EvictionAdvisor接口创建业务感知的驱逐逻辑：

java复制public class PriorityEvictionAdvisor<K,V> implements EvictionAdvisor<K,V> {
    @Override
    public boolean adviseForEviction(K key, V value) {
        if (value instanceof PriorityItem) {
            return ((PriorityItem) value).getPriority() < 5;
        }
        return false;
    }
}

// 配置使用
config.setEvictionAdvisor(new PriorityEvictionAdvisor<>());

5.2 多级缓存集成

典型架构：

code复制[热点数据] -> JCache(LRU) -> [温数据] -> Caffeine(LFU) -> [冷数据] -> Redis -> DB

配置示例：

java复制// 一级缓存（堆内）
MutableConfiguration<String, Object> l1Config = ...;
l1Config.setEvictionConfig(EvictionConfig.of(1000, EvictionPolicy.LRU));

// 二级缓存（堆外/磁盘）
MutableConfiguration<String, Object> l2Config = ...;
l2Config.setEvictionConfig(EvictionConfig.of(10_000, EvictionPolicy.LFU));

5.3 与Spring集成

Spring Cache抽象层支持JCache：

java复制@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {
    @Bean
    public CacheManager cacheManager() {
        CachingProvider provider = Caching.getCachingProvider();
        CacheManager cacheManager = provider.getCacheManager();
        
        MutableConfiguration<String, Product> config = new MutableConfiguration<>();
        config.setEvictionConfig(
            EvictionConfiguration.builder()
                .setMaxSize(500)
                .setEvictionPolicy(EvictionPolicy.LRU)
                .build()
        );
        
        cacheManager.createCache("products", config);
        return cacheManager;
    }
}

// 使用示例
@Service
public class ProductService {
    @Cacheable(value = "products", key = "#id")
    public Product getProduct(String id) {
        // 数据库查询逻辑
    }
}

5.4 最新技术趋势

新型驱逐算法：

1. W-TinyLFU（Caffeine采用）

   • 窗口过滤+频率统计
   • 高命中率低开销

2. LIRS（Low Inter-reference Recency Set）

   • 解决LRU的"一次访问"问题
   • 适合扫描类负载

硬件感知缓存：

• 使用CPU缓存行优化
• 考虑NUMA架构影响
• 持久化内存支持

我在实际项目中发现，对于现代SSD存储，结合容量驱逐和持久化配置能获得最佳性价比：

java复制config.setEvictionConfig(...);
config.setWriteThrough(true);
config.setReadThrough(true);
config.setCacheLoaderFactory(() -> new MyCacheLoader());
config.setCacheWriterFactory(() -> new MyCacheWriter());