1. 为什么高并发场景下,本地缓存是性能救星?
大家好,我是老张,一个在互联网大厂摸爬滚打了十年的后端老兵。这些年,我参与过不少高并发系统的设计和优化,从早期的电商秒杀,到后来的直播弹幕洪流,再到现在的实时风控系统,几乎每一个场景都绕不开一个核心问题:如何在海量请求下,依然保持系统的快速响应?
答案往往不是把数据库换成更贵的,也不是无脑地加机器,而是在应用和数据库之间,架设一道高效的“缓存”屏障。而这道屏障的第一道防线,就是本地缓存。想象一下,你开了一家网红奶茶店,每次有顾客点单,店员都要跑到几公里外的仓库去取原料,这队伍得排多长?但如果把最畅销的几款奶茶原料提前放在店里的冰柜(本地缓存),大部分订单就能瞬间搞定,效率提升立竿见影。
在SpringBoot项目中,当我们谈论本地缓存时,很多人会想到Guava Cache。它确实是个好工具,我也用了很多年。但后来,我遇到了Caffeine。简单说,Caffeine就是Guava Cache的“性能怪兽”升级版。它由同一位大神(Ben Manes)开发,但针对现代Java(尤其是JDK8+)和高并发场景做了深度优化。官方数据显示,其性能远超Guava和其他同类库,命中率接近最优值。Spring Framework从5.0开始,更是将Caffeine作为了默认的缓存实现,这足以说明它的江湖地位。
那么,在高并发场景下,为什么我们要选择Caffeine而不是其他方案呢?核心就两点:极致的速度和智能的淘汰策略。本地缓存的数据就在你的JVM堆内存里,访问速度是纳秒级的,这比通过网络访问Redis(微秒级)要快好几个数量级。对于那种访问频率极高、数据量不大、且允许短暂不一致的热点数据(比如系统配置、用户会话Token、热门商品信息),本地缓存是减少数据库压力、降低接口响应时间的首选利器。
2. Caffeine的制胜法宝:W-TinyLFU与异步加载
Caffeine之所以能成为性能王者,主要靠两大核心设计:W-TinyLFU淘汰算法和异步加载机制。这两点恰恰是应对高并发场景的杀手锏。
2.1 理解W-TinyLFU:不只是“最近使用”,更是“频繁使用”
在深入W-TinyLFU之前,我们得先聊聊传统缓存淘汰算法的“坑”。我早期用LRU(最近最少使用)算法时就踩过雷。LRU认为,最近被访问的数据,下次被访问的概率也高。这听起来合理,但在一种叫“扫描式访问”的场景下会失效。比如,你的系统有一个后台任务,需要周期性遍历全量用户ID进行检查。这个任务会一次性污染整个缓存,把真正的热点数据(比如正在活跃的用户信息)全部挤出去,导致缓存命中率暴跌。
另一种算法LFU(最不经常使用)记录了每个数据的访问频率,优先淘汰频率低的。这解决了LRU的扫描问题,但它又有新麻烦:历史包袱太重。如果一个数据曾经很火(比如一周前的爆款文章),但现在已经过气,可它的高频率计数会一直占着缓存位置,导致新的热点数据进不来。
Caffeine采用的W-TinyLFU算法,聪明地融合了LRU和LFU的优点。它的结构可以想象成一个有三层过滤的漏斗:
- 窗口缓存(Window Cache):这是一个很小的LRU队列,只占整个缓存的1%。所有新到的数据都先进入这里。这层的作用是应对突发流量。一个突然爆火的新数据,能快速进入缓存被服务。
- 过滤器(TinyLFU Filter):这是一个用“布隆过滤器”思想做的频率统计器,它用很小的空间记录了所有数据的近似访问频率。当数据从窗口缓存被挤出时,它需要和主缓存里将要被淘汰的数据“PK”。
- 主缓存(Main Cache):主缓存又分为保护段和淘汰段,都是LRU算法。在PK中胜出的数据,会进入主缓存的淘汰段。如果它在淘汰段被再次访问,就会升级进入保护段。保护段里的数据相对安全,不容易被淘汰。
这个流程的精妙之处在于,它既能通过窗口缓存快速响应突发访问,又能通过过滤器和主缓存的结构,长期保留那些真正被频繁访问的数据。在我负责的一个商品详情页系统中,接入Caffeine后,本地缓存命中率从原来Guava Cache的85%提升到了98%以上,效果非常显著。
2.2 异步加载与写入:别让缓存操作阻塞你的线程
高并发场景下,另一个致命问题是缓存穿透和缓存更新带来的线程阻塞。假设你的缓存里没有某个数据,这时一瞬间涌来1万个请求,它们都会发现缓存缺失(Cache Miss)。在传统的同步缓存(如Guava Cache)里,这1万个请求中的第一个会去数据库加载数据并写入缓存,而剩下的9999个,会被阻塞住,眼巴巴地等着第一个请求完成。这会造成请求线程的大量堆积,严重时甚至拖垮整个服务。
Caffeine为此提供了异步加载(AsyncLoadingCache) 这把利器。当缓存未命中时,Caffeine会返回一个CompletableFuture对象,而加载数据的行为被封装成一个异步任务。对于上面那个场景,第一个请求触发加载任务后,这个任务会被提交到后台线程池执行。而后续的9999个请求,拿到的是同一个CompletableFuture对象,它们都不会被阻塞,可以继续处理其他逻辑或者等待这个Future完成。这样一来,线程资源就被释放了,系统的吞吐量自然就上去了。
除了读,写操作也可以异步。通过Caffeine.executor()方法可以指定一个线程池,像refreshAfterWrite(写后刷新)这类操作就会在这个线程池中异步执行,不会阻塞主业务线程。我有个经验,在QPS超过5000的接口上,将缓存加载策略从同步改为异步,接口的平均响应时间直接下降了30%。
3. 实战:在SpringBoot中集成与配置Caffeine
理论说得再多,不如一行代码。下面我就带你一步步在SpringBoot项目中,搭建一个为高并发优化的Caffeine缓存。
3.1 方式一:原生API,精细控制
第一种方式是直接引入Caffeine依赖,使用其原生API。这种方式灵活度最高,你可以对缓存进行颗粒度极细的控制。
首先,在pom.xml中引入依赖:
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>3.1.8</version> <!-- 建议使用最新稳定版 -->
</dependency>
接下来,创建一个配置类来构建你的缓存实例。这里我展示一个为高并发优化的配置模板:
import com.github.ben-manes.caffeine.cache.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class HighConcurrencyCacheConfig {
@Bean
public AsyncLoadingCache<String, Object> asyncCache() {
return Caffeine.newBuilder()
// 初始容量,根据业务预估设置,减少扩容开销
.initialCapacity(1024)
// 最大容量,防止内存溢出
.maximumSize(10_000L)
// 写入后过期时间,根据数据一致性要求设定
.expireAfterWrite(10, TimeUnit.MINUTES)
// 访问后过期时间,适合热点数据动态维护
.expireAfterAccess(5, TimeUnit.MINUTES)
// 开启统计功能,方便监控调优
.recordStats()
// 使用自定义线程池进行异步刷新和加载(重要!)
.executor(MyThreadPool.getExecutor())
// 异步加载器:当缓存不存在时,如何加载数据
.buildAsync(new AsyncCacheLoader<String, Object>() {
@Override
public CompletableFuture<Object> asyncLoad(String key, Executor executor) {
return CompletableFuture.supplyAsync(() -> {
// 模拟从数据库或RPC服务加载数据
System.out.println("异步加载数据,key: " + key);
return "Data for " + key;
}, executor);
}
});
}
@Bean
public Cache<String, Object> manualCache() {
return Caffeine.newBuilder()
.initialCapacity(512)
.maximumSize(2000L)
// 基于权重的淘汰策略(例如,缓存值占用内存大小不同)
.weigher((String key, Object value) -> {
if (value instanceof String) {
return ((String) value).length();
}
return 1;
})
.maximumWeight(10_000_000L) // 总权重上限,与maximumSize二选一
// 弱引用键,在内存紧张时允许被GC回收(谨慎使用)
// .weakKeys()
// 软引用值,在内存不足时会被GC回收(可用于缓存大对象)
// .softValues()
// 移除监听器,用于日志记录或联动更新
.removalListener((String key, Object value, RemovalCause cause) ->
System.out.printf("Key %s was removed (%s)%n", key, cause))
.build();
}
}
关键参数解读:
maximumSizevsmaximumWeight:前者控制条目数量,后者控制总“重量”。如果你的缓存对象大小差异很大(比如有的存字符串,有的存大列表),用权重控制更精准。weakKeys/softValues:这些是基于引用的回收策略,能更灵活地响应JVM内存压力,但可能会带来==和equals比较的问题,使用时要小心。recordStats():强烈建议开启。通过cache.stats()可以拿到CacheStats对象,里面包含了命中率、加载时间、淘汰数量等黄金指标,是性能调优的依据。
使用这个异步缓存时,代码是这样写的:
@Service
public class ProductService {
@Autowired
private AsyncLoadingCache<String, Product> productCache;
public CompletableFuture<Product> getProductAsync(String productId) {
return productCache.get(productId);
}
// 如果你想以同步方式获取(阻塞直到数据加载完成)
public Product getProductSync(String productId) throws Exception {
return productCache.get(productId).get(); // 调用Future.get()
}
}
3.2 方式二:注解驱动,与Spring Cache无缝融合
如果你已经在使用Spring的@Cacheable等注解,那么第二种方式会让你感觉更顺手。它通过Spring Cache抽象层集成Caffeine,用声明式的方式管理缓存。
首先,需要添加Spring Cache和Caffeine两个依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>3.1.8</version>
</dependency>
在启动类上添加@EnableCaching注解开启缓存支持:
@SpringBootApplication
@EnableCaching
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
然后,配置Caffeine作为Spring的缓存管理器。这里我展示一个支持多缓存不同配置的进阶方案,这在实战中非常有用:
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import com.github.ben-manes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;
@Configuration
public class SpringCacheConfig {
/**
* 商品信息缓存:容量大,过期时间短,要求较高的实时性
*/
@Bean
public CacheManager productCacheManager() {
CaffeineCacheManager cacheManager = new CaffeineCacheManager("product");
cacheManager.setCaffeine(Caffeine.newBuilder()
.initialCapacity(1000)
.maximumSize(20_000L)
.expireAfterWrite(5, TimeUnit.MINUTES) // 5分钟过期
.recordStats());
return cacheManager;
}
/**
* 系统配置缓存:容量小,过期时间长,几乎不变
* 使用@Primary注解,使其成为默认缓存管理器
*/
@Bean
@Primary
public CacheManager configCacheManager() {
CaffeineCacheManager cacheManager = new CaffeineCacheManager("sysConfig", "userConfig");
cacheManager.setCaffeine(Caffeine.newBuilder()
.initialCapacity(100)
.maximumSize(500L)
.expireAfterWrite(1, TimeUnit.HOURS) // 1小时过期
.recordStats());
return cacheManager;
}
/**
* 用户会话缓存:基于访问时间过期,活跃用户数据常驻
*/
@Bean
public CacheManager sessionCacheManager() {
CaffeineCacheManager cacheManager = new CaffeineCacheManager("userSession");
cacheManager.setCaffeine(Caffeine.newBuilder()
.initialCapacity(5000)
.maximumSize(50_000L)
.expireAfterAccess(30, TimeUnit.MINUTES) // 30分钟无访问则过期
.recordStats());
return cacheManager;
}
}
在Service层,你就可以愉快地使用缓存注解了,并且可以指定不同的cacheManager:
@Service
public class ProductServiceImpl implements ProductService {
// 使用商品缓存管理器
@Cacheable(cacheNames = "product", cacheManager = "productCacheManager", key = "#id")
@Override
public Product getProductById(Long id) {
// 模拟耗时数据库查询
System.out.println("查询数据库,商品ID: " + id);
return productRepository.findById(id).orElse(null);
}
// 使用默认的(config)缓存管理器
@Cacheable(cacheNames = "sysConfig", key = "#configKey")
public String getSystemConfig(String configKey) {
return configRepository.findByKey(configKey);
}
// 更新缓存
@CachePut(cacheNames = "product", cacheManager = "productCacheManager", key = "#product.id")
public Product updateProduct(Product product) {
productRepository.update(product);
return product;
}
// 删除缓存
@CacheEvict(cacheNames = "product", cacheManager = "productCacheManager", key = "#id")
public void deleteProduct(Long id) {
productRepository.deleteById(id);
}
}
注解使用心得:
@Cacheable:最常用,适用于查询方法。注意unless属性,比如可以设置unless = "#result == null",避免缓存空值。@CachePut:总是执行方法体,并用结果更新缓存。适用于更新操作。@CacheEvict:删除缓存。在删除或更新导致数据失效时使用。allEntries = true可以清空整个缓存分区,慎用。key属性:设计良好的缓存键是关键。尽量使用业务主键,或组合关键参数。复杂的键可以自定义KeyGenerator生成。
4. 高并发场景下的进阶优化策略
基础搭建好了,但要应对真正的流量洪峰,我们还得有一些进阶的优化策略。这些都是我在实际压测和线上故障中总结出来的经验。
4.1 缓存预热与刷新策略
冷启动是缓存的一个大敌。系统刚启动时,缓存是空的,如果这时突然涌来大量请求,所有请求都会穿透到数据库,可能导致数据库瞬间被打垮。缓存预热就是解决方案。
我常用的预热方式是在应用启动后,由后台线程异步加载热点数据。结合Caffeine的异步加载特性,可以这样实现:
@Component
public class CacheWarmUpRunner implements ApplicationRunner {
@Autowired
private AsyncLoadingCache<String, HotProduct> hotProductCache;
@Autowired
private ProductService productService;
@Override
public void run(ApplicationArguments args) {
// 异步预热,不阻塞应用启动
CompletableFuture.runAsync(() -> {
List<String> top100ProductIds = productService.getTop100ProductIds();
top100ProductIds.forEach(id -> {
// 触发异步加载,数据会默默加载到缓存中
hotProductCache.get(id);
});
System.out.println("热点商品缓存预热完成,数量:" + top100ProductIds.size());
});
}
}
对于缓存刷新,Caffeine提供了refreshAfterWrite策略。注意,它和expireAfterWrite有本质区别。expire是过期后,下一次访问会同步阻塞地加载新值。而refresh是到期后,下一次访问会异步触发加载新值,但本次返回的依然是旧值。这非常适合那些加载成本高、但允许短暂读到旧数据的场景。
LoadingCache<String, Data> cache = Caffeine.newBuilder()
.maximumSize(1000)
.refreshAfterWrite(1, TimeUnit.MINUTES) // 写入1分钟后,下次访问触发异步刷新
.build(key -> expensiveLoadFromDB(key)); // 需要提供CacheLoader
4.2 监控与调优:让缓存状态一目了然
没有监控的缓存就像盲人骑马。Caffeine的recordStats()功能必须开启。我们可以定期(比如通过Spring Boot Actuator或自定义端点)输出缓存统计信息:
@Service
public class CacheMonitorService {
@Autowired
private CacheManager cacheManager;
public Map<String, Object> getCacheStats() {
Map<String, Object> statsMap = new HashMap<>();
cacheManager.getCacheNames().forEach(name -> {
com.github.ben-manes.caffeine.cache.Cache nativeCache = (com.github.ben-manes.caffeine.cache.Cache) cacheManager.getCache(name).getNativeCache();
CacheStats stats = nativeCache.stats();
Map<String, Object> stat = new HashMap<>();
stat.put("hitCount", stats.hitCount());
stat.put("missCount", stats.missCount());
stat.put("loadSuccessCount", stats.loadSuccessCount());
stat.put("loadFailureCount", stats.loadFailureCount());
stat.put("totalLoadTime", stats.totalLoadTime());
stat.put("evictionCount", stats.evictionCount());
stat.put("evictionWeight", stats.evictionWeight());
stat.put("hitRate", stats.hitRate()); // 命中率,核心指标!
statsMap.put(name, stat);
});
return statsMap;
}
}
关键指标解读:
- 命中率(hitRate):这是衡量缓存有效性的黄金指标。如果低于90%,就需要分析是容量不足、淘汰策略不对,还是数据本身就不适合缓存。
- 淘汰数量(evictionCount):如果这个值持续快速增长,说明缓存容量(
maximumSize)可能设置得太小,频繁的淘汰会产生额外开销。 - 平均加载时间(averageLoadPenalty):加载一个新值到缓存的平均耗时。如果这个时间很长,说明数据源(如DB)响应慢,或者加载逻辑复杂,需要考虑优化加载逻辑或使用
refreshAfterWrite来异步刷新。
4.3 避坑指南:高并发下的典型问题
- 缓存穿透:查询一个数据库中根本不存在的数据。每次请求都会打到数据库。解决方案:使用
CacheLoader并在加载方法中判断,如果数据库不存在,也缓存一个空值或特殊标记(如null),并设置一个较短的过期时间。或者在查询前,用布隆过滤器进行一层过滤。 - 缓存雪崩:大量缓存数据在同一时间过期,导致所有请求同时穿透到数据库。解决方案:给缓存过期时间加上一个随机值,避免集体失效。或者使用
refreshAfterWrite进行异步刷新,而不是直接过期。 - 缓存击穿:某个热点key过期,此时有大量并发请求这个key,全部穿透到数据库。解决方案:使用Caffeine的异步加载(
AsyncLoadingCache)是治本之策。或者使用互斥锁(如Redis的SETNX),只让一个线程去加载,其他线程等待,但在本地缓存场景下,异步加载方案更优雅高效。 - 内存溢出:本地缓存最大的风险。务必合理设置
maximumSize或maximumWeight。对于大对象,考虑使用softValues()让它们在内存紧张时能被GC回收,但要注意其对性能的轻微影响和比较语义的变化。
5. 场景化配置模板与性能对比
最后,我结合自己的经验,给出几个不同高并发场景下的配置模板,并做一个简单的性能对比分析。
场景一:电商商品详情页(读多写少,数据量中等)
Caffeine.newBuilder()
.initialCapacity(5000)
.maximumSize(50_000L) // 根据商品SKU数量估算
.expireAfterWrite(10, TimeUnit.MINUTES) // 商品信息变更不频繁,可适当延长
.refreshAfterWrite(5, TimeUnit.MINUTES) // 提前异步刷新,避免过期击穿
.recordStats()
.buildAsync(key -> loadProductFromDB(key));
策略考量:容量设大,过期时间适中,结合刷新策略保证数据相对新鲜且避免雪崩。
场景二:用户会话信息(读写都频繁,数据量大)
Caffeine.newBuilder()
.initialCapacity(10_000)
.maximumSize(100_000L) // 活跃会话数上限
.expireAfterAccess(30, TimeUnit.MINUTES) // 基于访问过期,活跃用户永驻
.weakKeys() // 允许JVM在内存紧张时回收不用的会话键
.recordStats()
.build();
策略考量:基于访问过期,保证活跃会话体验。使用弱引用键,增加内存弹性。
场景三:全局配置/字典数据(读极少写,数据量小,变更需感知)
Caffeine.newBuilder()
.initialCapacity(100)
.maximumSize(1000L)
.expireAfterWrite(1, TimeUnit.HOURS)
// 不设置refresh,依赖外部通知或定时任务全量更新缓存
.recordStats()
.build(key -> loadConfigFromDB(key));
策略考量:长过期时间,通过消息总线监听配置变更事件来主动失效或更新缓存。
为了让你更直观地看到优化效果,我曾在测试环境对一个查询接口做过对比。该接口平均每次查询数据库需要5ms。在QPS为3000的情况下:
- 无缓存:数据库连接池被打满,接口平均响应时间 > 200ms,大量超时。
- 使用Guava Cache:接口平均响应时间降至15ms,数据库压力减少70%。
- 使用Caffeine(异步加载+W-TinyLFU):接口平均响应时间进一步降至3ms以内,99.9%的请求在10ms内返回,数据库压力减少95%以上,且CPU和内存使用更加平稳。
这个对比清晰地告诉我们,在高并发战场上,选择一个像Caffeine这样设计先进的缓存组件,并进行合理的配置,往往能以最小的成本,获得最大的性能收益。它不仅仅是Guava Cache的替代品,更是面向现代高并发架构的必备利器。
1971



被折叠的 条评论
为什么被折叠?



