Java JCache 缓存驱逐与缓存过期的本质区别及触发机制解析

二、触发机制的深度解析

2.1 驱逐的触发机制：基于资源的压力响应

缓存操作检查缓存大小未达到阈值正常执行；达到或超过阈值触发驱逐机制。选择驱逐算法包括 LRU 最近最少使用、LFU 最不经常使用、FIFO 先进先出、随机驱逐等。

驱逐的核心触发逻辑：

public class EvictionTriggerMechanism {
    // 驱逐的典型触发点
    public void putWithEviction(K key, V value) {
        // 1. 检查是否需要驱逐
        if (needsEviction()) {
            // 2. 执行驱逐流程
            performEviction();
        }
        // 3. 执行原始操作
        doPut(key, value);
    }

    private boolean needsEviction() {
        // 多种触发条件
        return size.get() >= maxEntries ||
               memoryUsed.get() >= maxMemory ||
               diskUsed.get() >= maxDiskSpace ||
               systemMemoryPressure.isHigh();
    }

    private void performEviction() {
        // 驱逐执行流程
        int entriesToEvict = calculateEntriesToEvict();
        for (int i = 0; i < entriesToEvict; i++) {
            K keyToEvict = evictionPolicy.selectVictim();
            evictEntry(keyToEvict); // 执行驱逐
            evictionCount.increment(); // 更新统计
            fireEvictionEvent(keyToEvict); // 触发事件（如果配置）
        }
    }

    // 动态阈值调整（自适应驱逐）
    private int calculateEntriesToEvict() {
        int base = Math.max(1, size.get() / 10); // 移除 10%
        double pressure = calculateMemoryPressure();
        if (pressure > 0.9) base *= 2; // 高压力时加倍
        return Math.min(base, maxBatchEviction);
    }
}

2.2 过期的触发机制：基于时间的确定性检查

过期检查条件分为未过期和已过期。时间流通过定时检查器扫描缓存条目，检查过期条件后保留或标记为过期。清理策略选择包括立即移除、惰性移除、批量移除。

过期的核心触发逻辑：

public class ExpirationTriggerMechanism {
    // 三种主要的过期触发模式
    public class ExpirationModes {
        // 模式 1：主动定期扫描（最常见）
        public void scheduledExpirationCheck() {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            scheduler.scheduleAtFixedRate(() -> {
                checkAllEntriesForExpiration();
            }, 0, checkInterval, TimeUnit.SECONDS);
        }

        // 模式 2：惰性检查（访问时检查）
        public V getWithLazyExpiration(K key) {
            CacheEntry entry = getEntry(key);
            if (entry != null && isExpired(entry)) {
                removeEntry(key);
                return null;
            }
            return entry != null ? entry.getValue() : null;
        }

        // 模式 3：写时检查（维护有序数据结构）
        public void putWithExpirationAwareness(K key, V value) {
            expirationQueue.add(new ExpirationEntry(key, calculateExpiryTime()));
            ExpirationEntry next = expirationQueue.peek();
            if (next != null) scheduleExpirationAt(next.getExpiryTime());
        }
    }

    // 过期检查的具体实现
    private boolean isExpired(CacheEntry entry) {
        long currentTime = System.currentTimeMillis();
        return entry.getCreationTime() + entry.getTTL() <= currentTime ||
               entry.getLastAccessTime() + entry.getTTI() <= currentTime ||
               entry.getLastUpdateTime() + entry.getTTU() <= currentTime ||
               entry.getCustomExpiryCondition().isSatisfied(currentTime);
    }

    // 批量过期检查优化
    private void checkAllEntriesForExpiration() {
        int batchSize = 1000;
        int checked = 0;
        int expired = 0;
        Iterator<CacheEntry> iterator = cache.iterator();
        while (iterator.hasNext() && checked < batchSize) {
            CacheEntry entry = iterator.next();
            checked++;
            if (isExpired(entry)) {
                iterator.remove();
                expired++;
                if (listeners != null) fireExpiredEvent(entry.getKey(), entry.getValue());
            }
        }
        metrics.recordExpirationCheck(checked, expired);
        if (expired > checked * 0.3) adjustCheckInterval(true);
    }
}

三、JCache 中的实现差异

3.1 JCache 规范中的位置与配置

public class JCacheConfigurationExample {
    public void configureBothMechanisms() {
        MutableConfiguration<String, Data> config = new MutableConfiguration<>();
        // 1. 过期配置（Expiration）- 明确支持
        config.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_HOUR));
        // 2. 驱逐配置（Eviction）- 厂商扩展
        // JCache 规范没有标准 API 配置驱逐，需要通过厂商特定扩展配置
        // Ehcache 3 示例
        CacheConfigurationBuilder<String, Data> builder =
            CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, Data.class,
                ResourcePoolsBuilder.newResourcePoolsBuilder()
                    .heap(1000, EntryUnit.ENTRIES)
                    .offheap(1, MemoryUnit.GB));
        builder.withEvictionAdvisor((key, value) -> shouldEvict(key, value));
        CacheManager cacheManager = Caching.getCacheManager();
        Cache<String, Data> cache = cacheManager.createCache("cache", config);
        // 运行时行为模拟：两种机制独立工作，可能同时发生
    }
}

3.2 规范设计的哲学差异

为什么 JCache 规范这样设计？

1. 过期的时间语义是明确可标准化的。
2. 驱逐的资源语义是平台依赖的。
3. 过期是业务需求，驱逐是系统需求。
4. 实现复杂度的考虑，规范保持最小化。

四、实际场景中的交互与冲突

4.1 同时触发的处理策略

public class ConcurrentEvictionAndExpiration {
    // 策略 1：优先级处理
    public void handleWithPriority(Cache<K, V> cache) {
        CacheEntry entry = getEntry(key);
        // 情况 1：已过期，立即移除（过期优先）
        if (isExpired(entry)) {
            removeEntry(key);
            metrics.recordExpiration();
            return;
        }
        // 情况 2：未过期但需要驱逐空间
        if (needsEviction() && isEvictionCandidate(entry)) {
            evictEntry(key);
            metrics.recordEviction();
            return;
        }
        // 情况 3：既过期又是驱逐候选
        if (isExpired(entry) && isEvictionCandidate(entry)) {
            removeEntry(key);
            metrics.recordExpiration();
        }
    }

    // 策略 2：分层处理
    public class LayeredExpirationEviction {
        // 第一层：快速过期检查（每次访问）
        public V getWithFastExpirationCheck(K key) {
            CacheEntry entry = getEntry(key);
            if (entry != null && entry.isExpired()) {
                asyncRemoveExpired(key);
                return null;
            }
            return entry != null ? entry.getValue() : null;
        }

        // 第二层：定期批量过期扫描
        public void batchExpirationScan() { /* ... */ }

        // 第三层：驱逐作为最后手段
        public void evictIfNecessary() {
            if (isOverCapacity()) performEviction();
        }
    }
}

4.2 实际案例分析

public class EcommerceCacheScenario {
    public void analyzeRealWorldScenario() {
        Map<String, CacheConfig> configs = new HashMap<>();
        // 1. 商品详情 - 基于时间的过期
        configs.put("productDetail", newCacheConfig()
            .setExpiryPolicy(CreatedExpiryPolicy.of(Duration.ofHours(6)))
            .setEvictionPolicy(null));
        // 2. 商品价格 - 短时间过期 + 容量驱逐
        configs.put("productPrice", newCacheConfig()
            .setExpiryPolicy(CreatedExpiryPolicy.of(Duration.ofMinutes(5)))
            .setEvictionPolicy(newLRUEvictionPolicy(10000)));
        // 3. 用户会话 - 基于访问的过期 + 内存敏感驱逐
        configs.put("userSession", newCacheConfig()
            .setExpiryPolicy(AccessedExpiryPolicy.of(Duration.ofMinutes(30)))
            .setEvictionPolicy(newMemoryAwareEvictionPolicy(0.8)));
        // 4. 热门商品 - 长期保留，仅驱逐
        configs.put("hotProducts", newCacheConfig()
            .setExpiryPolicy(null)
            .setEvictionPolicy(newLFUEvictionPolicy(1000)));
    }
}

五、高级话题：现代缓存系统的演进

5.1 驱逐算法的演进

public class ModernEvictionAlgorithms {
    // 算法 1：TinyLFU - 适应现代工作负载
    public class TinyLFUEviction implements EvictionPolicy {
        private final CountMinSketch frequencySketch;
        private final BloomFilter admissionFilter;
        @Override
        public K selectVictim() {
            return findVictimByFrequencyAndRecency();
        }
    }
    // 算法 2：ARC - 自适应替换缓存
    // 算法 3：LIRS - 低互相关替换
}

5.2 过期机制的演进

public class ModernExpirationOptimizations {
    // 优化 1：分层时间轮（Hierarchical Timing Wheel）
    // 优化 2：概率过期（Probabilistic Expiration）
    // 优化 3：基于访问的过期预测
}

六、面试深度解析

6.1 面试考察维度

6.2 高级问题应对

问题：'在设计分布式缓存时，驱逐和过期会面临哪些额外挑战？'

public class DistributedCacheChallenges {
    public void explainDistributedChallenges() {
        // 挑战 1：一致性问题
        // 解决方案：使用逻辑时钟或版本号代替物理时间
        // 挑战 2：协调开销
        // 解决方案：使用租约（lease）机制管理过期
        // 挑战 3：网络分区
        // 解决方案：使用向量时钟（vector clock）跟踪因果关系
    }
}

问题：'如何设计一个既高效又公平的缓存清理策略？'

public class FairAndEfficientCleanup {
    public class SmartCleanupPolicy {
        public double calculateVictimScore(CacheEntry entry) {
            double score = 0.0;
            score += 1.0 / (entry.getAccessCount() + 1);
            score += (currentTime - entry.getLastAccessTime()) / 1000.0;
            score += entry.getSize() / 1024.0;
            score += getBusinessImportance(entry.getKey());
            if (entry.getExpiryTime() - currentTime < 60000) score += 10.0;
            return score;
        }
    }
}

七、总结：双重治理的艺术

缓存驱逐和过期代表了缓存系统的双重治理维度：

7.1 治理哲学总结

public class GovernancePhilosophy {
    public String expirationPhilosophy() {
        return """ 1. 基于契约：预先定义数据生命周期
                 2. 可预测性：明确的失效时间点
                 3. 业务导向：保证数据时效性和一致性
                 4. 主动预防：防止使用陈旧数据 """;
    }
    public String evictionPhilosophy() {
        return """ 1. 基于约束：响应系统资源限制
                 2. 适应性：根据访问模式动态调整
                 3. 系统导向：保证系统稳定性和性能
                 4. 被动反应：应对资源压力 """;
    }
}

7.2 架构师的关键洞察

对于高级开发者，深刻理解驱逐与过期的区别意味着：

1. 系统设计能力：能够为不同场景选择合适的清理策略
2. 性能优化能力：能够权衡各种策略的开销与收益
3. 问题诊断能力：能够分析缓存相关的性能问题
4. 架构演进能力：能够设计适应未来需求的缓存系统

在现代云原生和微服务架构中，缓存系统的双重治理机制变得更加重要。它们不仅是技术实现细节，更是系统稳定性、数据一致性和业务连续性的重要保障。能够精准运用这两种机制，是构建高性能、高可用分布式系统的关键技能之一。