SpringBoot 结合 Caffeine 优化高并发场景下的本地缓存性能

SpringBoot 集成 Caffeine 实现本地缓存 Caffeine 官网Caffeine 是基于Java 1.8 的高性能本地缓存库,同样是 Google 开发的,由 Guava 改进而来,底层设计思路、功能和使用方式与 Guava 非常类似,但是各方面的性能都要远远超过前者,可以看做是 Guava cache 的升级版。而且在 Spring5 开始的默认缓存实现就将 Caffeine 代替原来的 Google Guava,官方说明指出,其缓存命中率已经接近最优值@Data@Service@Autowired// 模拟数据库数据。 阅读详情

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的优点。它的结构可以想象成一个有三层过滤的漏斗:

  1. 窗口缓存(Window Cache):这是一个很小的LRU队列,只占整个缓存的1%。所有新到的数据都先进入这里。这层的作用是应对突发流量。一个突然爆火的新数据,能快速进入缓存被服务。
  2. 过滤器(TinyLFU Filter):这是一个用“布隆过滤器”思想做的频率统计器,它用很小的空间记录了所有数据的近似访问频率。当数据从窗口缓存被挤出时,它需要和主缓存里将要被淘汰的数据“PK”。
  3. 主缓存(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();
    }
}

关键参数解读:

  • maximumSize vs maximumWeight:前者控制条目数量,后者控制总“重量”。如果你的缓存对象大小差异很大(比如有的存字符串,有的存大列表),用权重控制更精准。
  • 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 避坑指南:高并发下的典型问题

  1. 缓存穿透:查询一个数据库中根本不存在的数据。每次请求都会打到数据库。解决方案:使用CacheLoader并在加载方法中判断,如果数据库不存在,也缓存一个空值或特殊标记(如null),并设置一个较短的过期时间。或者在查询前,用布隆过滤器进行一层过滤。
  2. 缓存雪崩:大量缓存数据在同一时间过期,导致所有请求同时穿透到数据库。解决方案:给缓存过期时间加上一个随机值,避免集体失效。或者使用refreshAfterWrite进行异步刷新,而不是直接过期。
  3. 缓存击穿:某个热点key过期,此时有大量并发请求这个key,全部穿透到数据库。解决方案:使用Caffeine的异步加载(AsyncLoadingCache)是治本之策。或者使用互斥锁(如Redis的SETNX),只让一个线程去加载,其他线程等待,但在本地缓存场景下,异步加载方案更优雅高效。
  4. 内存溢出:本地缓存最大的风险。务必合理设置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的替代品,更是面向现代高并发架构的必备利器。

SpringBoot 集成 Caffeine、Redis实现双重缓存方式(一) 一、本地缓存Caffeine介绍 一般情况下,缓存针对的主要是读操作。当你的功能遇到下面的场景时,就可以选择使用缓存组件进行性能优化: 存在数据热点,缓存的数据能够被频繁使用; 读操作明显比写操作要多; 下游功能存在着比较悬殊的性能差异,下游服务能力有限; 加入缓存以后,不会影响程序的正确性,或者引入不可预料的复杂性; 日常开发中,基本上每个项目中都会使用到Redis、MongoDB等缓存中间件,它能够很好的作为分布式缓存组件提供多个服务间的缓存,但是还是需要网络开销,增加时耗。 除了分布式缓存 阅读详情

相关推荐

springboot之本地缓存(guava与caffeine)

1. 场景描述 因项目要使用本地缓存,具体为啥不用redis等,就不讨论,记录下过程,希望能帮到需要的朋友。 2.解决方案 2.1 使用google的guava作为本地缓存 初步的想法是使用google的guava,因为本身项目中就有guava的denpency。 2.1.1 pom文件 需要3个dependency,如下: <!--软件老王 1--> <dependen...

软件老王 1971

别再用Redis了!本地缓存Caffeine在SpringBoot中的这几种用法,让接口性能飙升

本文探讨了在SpringBoot应用中使用Caffeine本地缓存替代Redis的性能优势,详细介绍了三种集成模式:注解驱动配置、异步加载与刷新机制、缓存预热与监控策略。通过电商商品详情页的实战案例,展示了Caffeine如何将平均响应时间从12ms降至1.2ms,并降低Redis流量83%。文章还提供了内存控制、缓存穿透防护和多级缓存融合的最佳实践。

weixin_30797199的博客 364

光储微电网混合储能系统的控制策略

随着社会生产力的不断提高,对不可再生资源的大量消耗,人们已经意识到发展可再生能源的重要性,因此微电网技术作为再生能源利用的有效形式被快速发展。蓄电池容量无限大是传统光储微电网混合储能系统控制策略一种理想形式,但实际上蓄电池的容量是有限度的,传统控制策略在蓄电池剩余电量达到阖值时将无法正常使用,由此提出了光储微电网混合储能系统的新型控制策略,又结合实际情况,对开关进行了改进,利用开关与二极管并联,使其拥有四种工作状态,当储能元件剩余电量达到阈值时,可自动恢复电量降低成本,提高并输出电池电能质量。

nhkg888的博客 1759

SpringBoot自习室预约系统开发与并发控制实践

分布式系统开发中,并发控制是保证数据一致性的关键技术。通过Redis分布式锁与数据库乐观锁的组合方案,可以有效解决高并发场景下的资源竞争问题。这种技术方案在电商秒杀、票务系统等需要强一致性的业务场景中广泛应用。本文以自习室座位预约系统为例,详细解析了如何利用SpringBoot快速构建高可用服务,其中Redis的SETNX命令实现分布式锁、MyBatis-Plus优化查询等实践,为毕业生开发类似系统提供了完整参考。系统采用三层架构设计,整合SpringSecurity实现安全控制,通过时间片算法提升资源利用

weixin_32288959的博客 331

EnlightenGAN训练复现记录

记录EnlightenGAN过程中的问题和解决方式。提示:以下是本篇文章正文内容,下面案例可供参考。

L_27N113E的博客 3850

5分钟搞懂知识抽取:如何把非结构化数据变成知识图谱的宝藏?

本文通过一个电商评论分析实战案例,详细解析了如何利用spaCy、Neo4j等工具,将非结构化文本数据转化为结构化知识图谱的完整流程。文章重点阐述了知识抽取的核心步骤,包括命名实体识别、关系抽取以及知识存储与查询,帮助读者快速掌握将数据转化为知识宝藏的关键技术。

weixin_29054245的博客 237

本地缓存Caffeine

Caffine 是一款高性能的近似LFU(最近最少频率使用)准入策略的本地缓存组件,Caffeine的底层数据存储采用ConcurrentHashMap,使用 Window TinyLfu 回收策略,提供了一个近乎最佳的命中率。适用范围:变更频率低、实时性要求低的数据之前的 removalListener 是异步监听,此处的 writer 方法可以设置同步监听器,同步监听器一个实现了接口 CacheWriter 的实例化对象,我们需要自定义接口的实现类。

m0_57801749的博客 1万+

開機自動進入UEFI Interactive Shell無法正常開機怎麼辦?

BIOS/UEFI,啟動後進入UEFI Interactive Shell大多數人都告訴你沒有安裝系統去裝系統吧,但你明明昨天還在運行系統?今天就這樣?有沒有解決辦法?

sheaahhoi1的博客 7749

高性能 Java 本地缓存 Caffeine 框架介绍及在 SpringBoot 中的使用

Caffeine 是一个用于 Java 的缓存库,其设计目标是高性能,和近乎最佳的命中率。缓存库的主要功能是存储和快速检索数据,以减少直接访问数据源(例如数据库或远程服务)的次数,从而提高应用程序的性能。Caffeine 的 “高性能” 表示它在处理缓存操作时速度很快,并且占用的资源较少。“近乎最佳的命中率” 指的是 Caffeine 在缓存命中(即请求的数据已经存在于缓存中)方面表现非常出色。高命中率意味着大多数数据请求都可以直接从缓存中获得,而无需访问原始数据源,从而大大提高了效率和响应速度。

栗筝i的博客 2735

强化学习 | Multi Agents | Trust Region | HATRPO | HAPPO

ICLR2022多智能体论文,将trust region推广到MA上,保证单调递增。学习博客,共7k字,纯手敲。含大量手写笔记。

111辄的博客 1万+

FFTW3库在Windows中的安装和使用

Windows 32位平台下载:FFTW Installation on Windows。

weixin_45397344的博客 953

【SpringBoot教程】SpringBoot整合Caffeine本地缓存及Spring Cache注解的使用

本地缓存之王!Caffeine!

神马都会亿点点的毛毛张 8761

Open3D 计算点云模型的表面积和体积【2025最新版】

python编程实现 计算点云模型的表面积和体积,博客长期更新,本文最近一次更新时间为:2025年4月4日。

点云侠的博客 13万+

【SpringBoot应用篇】SpringBoot集成Caffeine本地缓存

缓存在日常开发中启动至关重要的作用,由于是存储在内存中,数据的读取速度是非常快的,能大量减少对数据库的访问,减少数据库的压力。之前介绍过 Redis 这种 NoSql 作为缓存组件,它能够很好的作为分布式缓存组件提供多个服务间的缓存,但是 Redis 这种还是需要网络开销,增加时耗。本地缓存是直接从本地内存中读取,没有网络开销,例如秒杀系统或者数据量小的缓存等,比远程缓存更合适。

输入技术、输出想法 3145

使用MATLAB中的Simulink工具来构建一个微电网系统的仿真平台

微电网是指由分布式电源(如太阳能、风能等)、储能装置、负载以及控制和保护装置组成的局部电力系统。它可以独立于主电网运行,也可以与主电网并联运行。本示例将以一个简单的微电网为例,展示如何利用Simulink进行微电网接入与孤岛运行策略的设计与仿真。分布式电源:模拟太阳能光伏板或风力发电机等分布式电源。储能装置:用于存储多余能量或补充不足能量。负载:模拟实际用电需求。双向变流器:实现直流与交流之间的转换,并支持并网和孤岛模式切换。控制器:负责管理微电网的运行模式,包括并网控制和孤岛控制。

xiaoheshang_123的博客 348

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Caffeine本地缓存

caffine

小刺猬 1万+

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

SpringBoot整合Caffeine本地缓存

高性能:Caffeine具有极快的读写性能,适合高并发的场景。丰富的缓存策略:支持基于时间、大小等多种缓存失效策略。自动回收:内存占用达到限制后会自动回收不常用的缓存。相较于其他缓存解决方案(如Guava),Caffeine提供了更高的性能和更多的缓存控制选项,适合在Spring Boot中作为本地缓存解决方案。定义一个User。

u013257321的博客 1331

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

caffeine本地缓存入门及实战

Caffeine是基于Java 8开发的高性能本地缓存库,设计目标是提供高吞吐量、低延迟的内存缓存解决方案。其核心改进源自Guava Cache,但通过优化并发控制(如StampedLock)和淘汰算法(Window-TinyLFU),性能显著提升。性能碾压:基于Window-TinyLFU算法,缓存命中率比LRU提升20%+;易用性:API设计简洁,与Spring无缝集成,支持注解式缓存;灵活性:覆盖本地缓存全场景需求(同步/异步加载、多维度过期策略)。

qq_23097225的博客 1680
上一篇: 深入解析DDR5 SDRAM的ODT模式:时序图与状态表实战指南
下一篇: 通义千问联网搜索功能实现原理与技术实践
人间清醒863
博客等级 码龄3年 33粉丝 1544原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值