【缓存】本地缓存Caffeine AsyncCache实现原理与最佳实践

AsyncCache：JVM 级 SingleFlight 实现原理与最佳实践

本文基于CaffeineAsyncCache+Java 8+，适用于需要高并发下防止缓存击穿、避免重复加载的场景。

一、核心目标：同一 Key 只加载一次

在高并发场景下，缓存失效瞬间可能出现缓存击穿（Cache Breakdown）：

大量线程同时发现缓存缺失，同时去 DB / RPC 加载同一份数据。

AsyncCache的目标就是：无论多少线程并发访问，同一个 Key 只触发一次加载逻辑。

二、核心实现原理

1. 原子性保障：ConcurrentHashMap.computeIfAbsent

AsyncCache底层依赖ConcurrentHashMap，核心逻辑等价于：

CompletableFuture<V>future=map.computeIfAbsent(key,k->{// ✅ 同一时刻，只有一个线程能进入此处CompletableFuture<V>f=newCompletableFuture<>();executor.execute(()->{try{Vvalue=loadFromDb(k);f.complete(value);}catch(Throwablet){f.completeExceptionally(t);map.remove(k,f);// 加载失败，允许重试}});returnf;});

关键保证

✅这就是 JVM 级的 SingleFlight 实现

2. Java 8 的并发控制：CAS +synchronized桶级锁

⚠️重要更正：Java 8 中ConcurrentHashMap已废弃 JDK 7 的 Segment 分段锁（Striped Locking），改用CAS 无锁 +synchronized桶级锁的混合策略。

JDK 7 vs JDK 8 对比

computeIfAbsent的执行流程（Java 8）

线程 T1、T2、T3 同时调用 computeIfAbsent("sameKey", ...) │ ▼ ① 计算 hash，定位到桶下标 i │ ▼ ② 桶为空？── 是 ──→ CAS 直接插入（无锁快路径） │ 否 ▼ ③ synchronized 锁住桶的头节点 │ ▼ ④ 再次检查 key 是否仍不存在（double check） │ ▼ ⑤ 只有一个线程执行 mappingFunction │ ▼ ⑥ 释放锁，其他线程拿到同一个 Future

核心要点：

1. CAS 优先：无竞争时完全无锁，性能极高
2. synchronized锁桶头节点：只有发生哈希冲突时才加锁，且锁粒度极小
3. 锁升级机制：JVM 会自动将synchronized从偏向锁 → 轻量级锁 → 重量级锁逐步升级，绝大多数场景停留在轻量级锁阶段
4. 不同桶之间完全无竞争：并发度约等于桶数组长度（默认 16，可随扩容增长）

为什么 Java 8 选择synchronized而非ReentrantLock？

结论：在ConcurrentHashMap这种锁持有时间极短、不需要条件变量和中断特性的场景下，synchronized经过 JVM 优化后性能全面优于ReentrantLock，且零内存开销。

3. 自动清理与内存安全

• Future 完成后，引用由 GC 自动回收
• 加载失败时主动remove(key)，避免：
  • 空值缓存
  • 永久阻塞
  • 内存泄漏

三、推荐写法

✅ 基础用法（最推荐）

publicStringgetData(Stringkey){returnasyncCache.get(key,(k,exec)->CompletableFuture.supplyAsync(()->loadDataFromDb(k),exec)).join();}

• exec：Caffeine 内置ForkJoinPool，生产环境建议自定义线程池
• join()：阻塞等待结果，适合非响应式服务

✅ 带超时保护（防止线程堆积）

publicStringgetDataWithTimeout(Stringkey){returnasyncCache.get(key,(k,exec)->CompletableFuture.supplyAsync(()->loadDataFromDb(k),exec).completeOnTimeout("fallback",2,TimeUnit.SECONDS)).join();}

✅ 防止：

• DB 慢查询
• RPC 无限阻塞
• 线程池被打爆

✅ 防止缓存污染（加载失败不缓存）

publicStringgetDataSafe(Stringkey){returnasyncCache.get(key,(k,exec)->CompletableFuture.supplyAsync(()->loadDataFromDb(k),exec).exceptionally(ex->{asyncCache.synchronous().invalidate(k);thrownewRuntimeException(ex);})).join();}

📌非常重要：否则失败结果会被缓存，导致后续请求全部失败。

五、原子更新 Value

如果你是想做CAS 风格更新：

cache.asMap().compute(key,(k,oldFuture)->{if(oldFuture==null){returnCompletableFuture.completedFuture("init");}returnoldFuture.thenApply(v->v+"_updated");});

⚠️ 注意：

• AsyncCache中 Value 是CompletableFuture
• 更新成本较高，通常不建议频繁使用

六、并发测试验证

publicstaticvoidmain(String[]args){AsyncCache<String,String>cache=Caffeine.newBuilder().buildAsync();AtomicIntegerloadCount=newAtomicInteger(0);List<CompletableFuture<String>>futures=IntStream.range(0,10).parallel().mapToObj(i->cache.get("sameKey",(key,exec)->{System.out.println(Thread.currentThread().getName()+" loading...");loadCount.incrementAndGet();returnCompletableFuture.supplyAsync(()->"Data-"+key);})).toList();futures.get(0).whenComplete((v,ex)->{System.out.println("Result: "+v);});System.out.println("Load count = "+loadCount.get());// ✅ 永远是 1}

典型输出

ForkJoinPool.commonPool-worker-1 loading... Result: Data-sameKey Load count = 1

✅完美证明：仅一个线程执行加载逻辑

七、与 Redis 分布式锁对比

✅结论：能使用AsyncCache解决的场景，不要用 Redis 锁。二者不是替代关系，而是互补——分布式场景仍需 Redis，单机高并发场景AsyncCache是更优解。

八、避坑指南

❌ 坑 1：在computeIfAbsent的 Lambda 中再次操作同一个 Map

// 错误示范：可能导致死锁map.computeIfAbsent("key",k->{map.put("otherKey",someValue);// ⚠️ Lambda 内可能持有桶锁，再次操作可能死锁returncomputeValue();});

✅正确做法：Lambda 内只做纯计算，不涉及任何 Map 写操作。

❌ 坑 2：mappingFunction返回null

computeIfAbsent的mappingFunction不允许返回 null，否则抛出NullPointerException。

// 错误cache.get(key,k->null);// NPE!// 正确：返回包装类型或 Optionalcache.get(key,k->CompletableFuture.completedFuture(null));// OK

[citation:6]

❌ 坑 3：mappingFunction执行时间过长

computeIfAbsent在执行 Lambda 时持有桶锁（虽然时间极短），如果 Lambda 内做耗时操作，会阻塞同一桶的其他操作。

✅正确做法：Lambda 内只创建CompletableFuture，实际计算交给异步线程：

// ✅ 推荐：Lambda 立即返回 Future，计算异步执行cache.get(key,(k,exec)->{returnCompletableFuture.supplyAsync(()->loadDataFromDb(k),exec);});

九、总结

CaffeineAsyncCache通过ConcurrentHashMap.computeIfAbsent实现了 JVM 级的 SingleFlight。在 Java 8 中，底层依赖 CAS 无锁 +synchronized桶级锁的混合策略，以极低的锁开销保证同一 Key 只加载一次。

核心要点速查

十、参考与延伸阅读

• JDK 源码：ConcurrentHashMap.computeIfAbsent()（JDK 8u60+）
• Caffeine 官方文档：https://github.com/ben-manes/caffeine
• Java 8synchronized锁升级机制：偏向锁 → 轻量级锁 → 重量级锁
• CompletableFuture超时 API：Java 9+completeOnTimeout/ Java 8 GuavaFutures.withTimeout