Java是否存在支持首次插入后定时过期的Expiring Map？

嘿，我完全懂你的需求——Guava Cache的expireAfterWrite确实是按最后写入时间算过期的，这显然不符合你要的“首次执行任务后，固定时段内保持静默，过期后再响应”的逻辑。你需要的是严格基于键创建时间的TTL过期策略，不管后续有没有访问，到点就自动清理键值对。

下面给你几个实用的解决方案，从第三方库到轻量手动实现都有：

方案1：用Caffeine Cache直接搞定（最推荐） #

如果你能把Guava换成Caffeine（它是Guava Cache的继任者，性能更好，API也兼容），那简直是完美匹配——Caffeine直接支持expireAfterCreate，就是专门按创建时间算TTL的：

// 初始化缓存，设置1小时的静默窗口期（可按需调整）
LoadingCache<String, Long> taskCounterCache = Caffeine.newBuilder()
        .expireAfterCreate(1, TimeUnit.HOURS)
        .removalListener((key, count, cause) -> {
            // 可选：缓存过期/被移除时的回调逻辑，比如打印日志
        })
        .build(key -> 0L); // 首次加载时计数器初始化为0

// 判断是否需要执行任务的核心方法
public boolean shouldTriggerTask(String taskKey) {
    // 先查缓存，如果不存在（说明过期或从未执行过），就允许执行
    if (taskCounterCache.getIfPresent(taskKey) == null) {
        taskCounterCache.put(taskKey, 1L);
        return true;
    } else {
        // 缓存存在，计数器+1（记录这段时间内收到的请求数），返回false保持静默
        taskCounterCache.asMap().compute(taskKey, (k, currentCount) -> currentCount + 1);
        return false;
    }
}

这个方案的优势就是完全不需要自己写过期判断逻辑，Caffeine会自动按创建时间清理，后续的任何访问都不会重置TTL，完美契合你的场景。

方案2：基于Guava Cache改造（必须用Guava的情况） #

如果没法换库，那我们可以给Guava Cache的“值”加个包装，把创建时间存进去，每次访问时手动判断是否过期：

// 包装类：存计数器和创建时间
static class TaskCacheValue {
    long requestCount;
    long createTimestamp;

    TaskCacheValue(long count) {
        this.requestCount = count;
        this.createTimestamp = System.currentTimeMillis();
    }
}

// 初始化Guava Cache，设置一个足够长的默认过期时间（比如24小时）
LoadingCache<String, TaskCacheValue> guavaTaskCache = CacheBuilder.newBuilder()
        .expireAfterWrite(24, TimeUnit.HOURS)
        .removalListener((RemovalNotification<String, TaskCacheValue> notification) -> {
            // 可选：清理后的回调
        })
        .build(new CacheLoader<String, TaskCacheValue>() {
            @Override
            public TaskCacheValue load(String key) {
                // 首次加载时初始化
                return new TaskCacheValue(0);
            }
        });

// 判断是否执行任务
public boolean shouldTriggerTask(String taskKey, long silentWindowMillis) {
    try {
        TaskCacheValue value = guavaTaskCache.get(taskKey);
        long currentTime = System.currentTimeMillis();
        
        // 检查是否超过静默窗口期
        if (currentTime - value.createTimestamp > silentWindowMillis) {
            // 已过期，移除旧键，允许执行任务
            guavaTaskCache.invalidate(taskKey);
            return true;
        } else {
            // 未过期，计数器+1，返回false
            guavaTaskCache.put(taskKey, new TaskCacheValue(value.requestCount + 1));
            return false;
        }
    } catch (ExecutionException e) {
        // 加载异常时默认允许执行任务
        return true;
    }
}

这里的思路是把实际的TTL逻辑从Guava的过期机制里抽出来，自己手动判断，Guava只负责存储和基础的过期兜底。

方案3：手动实现轻量版（无第三方库依赖） #

如果你的场景很简单，不想引入任何缓存库，用ConcurrentHashMap加定时任务就能搞定：

// 存储键：<任务ID, <创建时间戳, 请求计数器>>
private final ConcurrentHashMap<String, Pair<Long, Long>> simpleCache = new ConcurrentHashMap<>();
// 定时清理线程池
private final ScheduledExecutorService cleaner = Executors.newSingleThreadScheduledExecutor();

public SimpleTaskCache() {
    // 每分钟清理一次过期键（这里设1小时TTL，可调整）
    cleaner.scheduleAtFixedRate(() -> {
        long now = System.currentTimeMillis();
        simpleCache.entrySet().removeIf(entry -> {
            long createTime = entry.getValue().getKey();
            return now - createTime > 3600_000;
        });
    }, 0, 1, TimeUnit.MINUTES);
}

public boolean shouldTriggerTask(String taskKey) {
    Pair<Long, Long> cacheValue = simpleCache.get(taskKey);
    if (cacheValue == null) {
        // 不存在，插入新记录，允许执行
        simpleCache.put(taskKey, new Pair<>(System.currentTimeMillis(), 1L));
        return true;
    } else {
        // 存在，计数器+1，保持静默
        simpleCache.put(taskKey, new Pair<>(cacheValue.getKey(), cacheValue.getValue() + 1));
        return false;
    }
}

这个方案适合轻量级场景，不需要依赖，但要注意定时任务的线程安全和资源占用。

最后总结 #

• 优先选Caffeine，直接支持你要的创建时间TTL，代码最简洁；
• 必须用Guava的话，就用包装类手动判断过期；
• 轻量场景自己用ConcurrentHashMap+定时任务实现。

内容的提问来源于stack exchange，提问作者AlikElzin-kilaka