Caffeine--缓存组件

2023-12-28 13:36
文章标签 组件 缓存 caffeine

本文主要是介绍Caffeine--缓存组件,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

Caffeine

  • 概念
  • 缓存
    • 手动加载
    • 自动加载
    • 手动异步加载
    • 自动异步加载
  • 驱逐策略
    • 基于容量
    • 基于时间
    • 基于引用
  • 移除
    • 显式移除

概念

Caffeine是一个基于Java8开发的提供了近乎最佳命中率的高性能的缓存库。与ConcurrentMap有点相似。最根本的区别是ConcurrentMap将会持有所有加入到缓存当中的元素,直到它们被从缓存当中手动移除。Caffeine的缓存Cache 通常会被配置成自动驱逐缓存中元素,以限制其内存占用。在某些场景下,LoadingCacheAsyncLoadingCache尤为重要。

Caffeine提供了灵活的构造器去创建一个拥有下列特性的缓存:
(1)自动加载元素到缓存当中,异步加载的方式也可供选择
(2)当达到最大容量的时候可以使用基于就近度和频率的算法进行基于容量的驱逐
(3)将根据缓存中的元素上一次访问或者被修改的时间进行基于过期时间的驱逐
(4)当向缓存中一个已经过时的元素进行访问的时候将会进行异步刷新
(5)key将自动被弱引用所封装
(6)value将自动被弱引用或者软引用所封装
(7)驱逐(或移除)缓存中的元素时将会进行通知
(8)写入传播到一个外部数据源当中
(9)持续计算缓存的访问统计指标

缓存

Caffeine提供了四种缓存添加策略:手动加载自动加载手动异步加载自动异步加载

手动加载

		Cache<String, String> cache = Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).maximumSize(10000).build();// 查找一个缓存元素, 没有查找到的时候返回nullString s=cache.getIfPresent("xiaohei");// 查找缓存,如果缓存不存在则生成缓存元素,  如果无法生成则返回nulls= cache.get("xiaohei", k -> new String("啥也没有"));// 添加或者更新一个缓存元素cache.put("xiaohei1", new String());// 移除一个缓存元素cache.invalidate("xiaohei");

Cache 接口提供了显式搜索查找、更新和移除缓存元素的能力。
推荐使用cache.get(key, k -> value)操作来在缓存中不存在该key对应的缓存元素的时候进行计算生成并直接写入至缓存内,而当该key对应的缓存元素存在的时候将会直接返回存在的缓存值。一次 cache.put(key, value) 操作将会直接写入或者更新缓存里的缓存元素,在缓存中已经存在的该key对应缓存值都会直接被覆盖。也可以使用Cache.asMap()所暴露出来的ConcurrentMap的方法对缓存进行操作。

自动加载

LoadingCache<String, String> cache = Caffeine.newBuilder().maximumSize(10000).expireAfterWrite(10, TimeUnit.MINUTES).build(key -> new String("啥也没有"));
// 查找缓存,如果缓存不存在则生成缓存元素,  如果无法生成则返回nullString s = cache.get("xiaohei");
// 批量查找缓存,如果缓存不存在则生成缓存元素Map<String, String> map = cache.getAll(Arrays.asList(new String[]{"xiaohei1", "xiaohei2"}));

一个LoadingCache是一个Cache 附加上CacheLoader能力之后的缓存实现。默认情况下,在getAll 方法中,将会对每个不存在对应缓存的key调用一次CacheLoader.load来生成缓存元素。

手动异步加载

		AsyncCache<String, String> cache = Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).maximumSize(10000).buildAsync();// 查找一个缓存元素, 没有查找到的时候返回nullCompletableFuture<String> graph = cache.getIfPresent("xiaohei");// 查找缓存元素,如果不存在,则异步生成graph = cache.get("xiaohei", k -> new String("xiaoheissss"));// 添加或者更新一个缓存元素cache.put("xiaobai", graph);// 移除一个缓存元素cache.synchronous().invalidate("xiaohei");

一个AsyncCache是Cache的一个变体,AsyncCache提供了在Executor上生成缓存元素并返回 CompletableFuture的能力。这给出了在当前流行的响应式编程模型中利用缓存的能力。
synchronous()方法给Cache提供了阻塞直到异步缓存生成完毕的能力。也可以使用 AsyncCache.asMap()所暴露出来的ConcurrentMap的方法对缓存进行操作。默认的线程池实现是 ForkJoinPool.commonPool() ,也可以通过覆盖并实现 Caffeine.executor(Executor)方法来自定义线程池选择。

自动异步加载

		AsyncLoadingCache<String, String> cache = Caffeine.newBuilder().maximumSize(10000).expireAfterWrite(10, TimeUnit.MINUTES)// 你可以选择: 去异步的封装一段同步操作来生成缓存元素.buildAsync(key -> new String(key));// 你也可以选择: 构建一个异步缓存元素操作并返回一个future
//                .buildAsync((key, executor) -> createExpensiveGraphAsync(key, executor));// 查找缓存元素,如果其不存在,将会异步进行生成CompletableFuture<String> graph = cache.get("xiaohei");
// 批量查找缓存元素,如果其不存在,将会异步进行生成CompletableFuture<Map<String, String>> graphs = cache.getAll(Arrays.asList(new String[]{"xiaohei1", "xiaohei2"}));

一个 AsyncLoadingCache是一个AsyncCache加上AsyncCacheLoader能力的实现。在需要同步的方式去生成缓存元素的时候,CacheLoader是合适的选择。而在异步生成缓存的场景下,AsyncCacheLoader则是更合适的选择并且它会返回一个 CompletableFuture。默认情况下,在getAll 方法中,将会对每个不存在对应缓存的key调用一次 AsyncCacheLoader.asyncLoad 来生成缓存元素。 可以通过实现一个 AsyncCacheLoader.asyncLoadAll并在其中为没有在参数中请求的key也生成对应的缓存元素。如果对应某个key生成的缓存元素与包含这个key的一组集合剩余的key所对应的元素一致,那么在asyncLoadAll中也可以同时加载剩下的key对应的元素到缓存当中。

驱逐策略

基于容量

Caffeine提供了三种驱逐策略,分别是基于容量,基于时间和基于引用三种类型。

// 基于缓存内的元素个数进行驱逐
LoadingCache<String, String> graphs = Caffeine.newBuilder().maximumSize(10000).build(key -> new String(key));
// 基于缓存内元素权重进行驱逐
LoadingCache<String, String> graphs = Caffeine.newBuilder().maximumWeight(10000).weigher((String s, String s1) -> s1.length()).build(key -> new String(key));

基于缓存内的元素个数进行驱逐策略中,使用Caffeine.maximumSize(long)。缓存将会尝试通过基于就近度和频率的算法来驱逐掉不会再被使用到的元素。
缓存中的元素可能有不同的内存占用–需要借助Caffeine.weigher(Weigher)方法来界定每个元素的权重并通过 Caffeine.maximumWeight(long)方法来界定缓存中元素的总权重来实现上述的场景。在基于权重驱逐的策略下,一个缓存元素的权重计算是在其创建和更新时,此后其权重值都是静态存在的,在两个元素之间进行权重的比较的时候,并不会根据进行相对权重的比较。

基于时间

// 基于固定的过期时间驱逐策略LoadingCache<String, String> graphs1 = Caffeine.newBuilder().expireAfterAccess(5, TimeUnit.MINUTES).build(key -> new String());LoadingCache<String, String> graphs2 = Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).build(key -> new String());// 基于不同的过期驱逐策略LoadingCache<String, String> graphs = Caffeine.newBuilder().expireAfter(new Expiry<String, String>() {@Overridepublic long expireAfterCreate(@NonNull String s, @NonNull String s2, long l) {return 0;}@Overridepublic long expireAfterUpdate(@NonNull String s, @NonNull String s2, long l, @NonNegative long l1) {return 0;}@Overridepublic long expireAfterRead(@NonNull String s, @NonNull String s2, long l, @NonNegative long l1) {return 0;}}).build(key -> new String());

expireAfterAccess(long, TimeUnit): 一个元素在上一次读写操作后一段时间之后,在指定的时间后没有被再次访问将会被认定为过期项。在当被缓存的元素时被绑定在一个session上时,当session因为不活跃而使元素过期的情况下,这是理想的选择。
expireAfterWrite(long, TimeUnit): 一个元素将会在其创建或者最近一次被更新之后的一段时间后被认定为过期项。在对被缓存的元素的时效性存在要求的场景下,这是理想的选择。
expireAfter(Expiry): 一个元素将会在指定的时间后被认定为过期项。当被缓存的元素过期时间收到外部资源影响的时候,这是理想的选择。

基于引用

		// 当key和缓存元素都不再存在其他强引用的时候驱逐LoadingCache<String, String> graphs1 = Caffeine.newBuilder().weakKeys().weakValues().build(key -> new String());// 当进行GC的时候进行驱逐LoadingCache<String, String> graphs2 = Caffeine.newBuilder().softValues().build(key -> new String());

Caffeine 允许去让GC去帮助清理缓存当中的元素,其中key支持弱引用,而value则支持弱引用和软引用。AsyncCache不支持软引用和弱引用。
Caffeine.weakKeys():在保存key的时候将会进行弱引用。这允许在GC的过程中,当key没有被任何强引用指向的时候去将缓存元素回收。由于GC只依赖于引用相等性。这导致在这个情况下,缓存将会通过引用相等(==)而不是对象相等 equals()去进行key之间的比较。

Caffeine.weakValues():在保存value的时候将会使用弱引用。这允许在GC的过程中,当value没有被任何强引用指向的时候去将缓存元素回收。由于GC只依赖于引用相等性。这导致在这个情况下,缓存将会通过引用相等(==)而不是对象相等 equals()去进行value之间的比较。

Caffeine.softValues():在保存value的时候将会使用软引用。为了相应内存的需要,在GC过程中被软引用的对象将会被通过LRU算法回收。由于使用软引用可能会影响整体性能,我们还是建议通过使用基于缓存容量的驱逐策略代替软引用的使用。同样的,使用 softValues() 将会通过引用相等(==)而不是对象相等equals()去进行value之间的比较。

移除

驱逐:缓存元素因为策略被移除
失效:缓存元素被手动移除
移除:由于驱逐或者失效而最终导致的结果

显式移除

可以手动去让某个缓存元素失效而不是只能等待其因为策略而被驱逐。

// 失效key
cache.invalidate("小黑");
// 批量失效key
cache.invalidateAll(Arrays.asList(new String[]{"xiaohei1", "xiaohei2"}));
// 失效所有的key
cache.invalidateAll();

这篇关于Caffeine--缓存组件的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/546115

相关文章

Vue中组件之间传值的六种方式(完整版)

《Vue中组件之间传值的六种方式(完整版)》组件是vue.js最强大的功能之一,而组件实例的作用域是相互独立的,这就意味着不同组件之间的数据无法相互引用,针对不同的使用场景,如何选择行之有效的通信方式... 目录前言方法一、props/$emit1.父组件向子组件传值2.子组件向父组件传值(通过事件形式)方

Linux修改pip和conda缓存路径的几种方法

《Linux修改pip和conda缓存路径的几种方法》在Python生态中,pip和conda是两种常见的软件包管理工具,它们在安装、更新和卸载软件包时都会使用缓存来提高效率,适当地修改它们的缓存路径... 目录一、pip 和 conda 的缓存机制1. pip 的缓存机制默认缓存路径2. conda 的缓

Redis解决缓存击穿问题的两种方法

《Redis解决缓存击穿问题的两种方法》缓存击穿问题也叫热点Key问题,就是⼀个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大的冲击,本文给大家介绍了Re... 目录引言解决办法互斥锁(强一致,性能差)逻辑过期(高可用,性能优)设计逻辑过期时间引言缓存击穿:给

Spring组件初始化扩展点BeanPostProcessor的作用详解

《Spring组件初始化扩展点BeanPostProcessor的作用详解》本文通过实战案例和常见应用场景详细介绍了BeanPostProcessor的使用,并强调了其在Spring扩展中的重要性,感... 目录一、概述二、BeanPostProcessor的作用三、核心方法解析1、postProcessB

kotlin中的行为组件及高级用法

《kotlin中的行为组件及高级用法》Jetpack中的四大行为组件:WorkManager、DataBinding、Coroutines和Lifecycle,分别解决了后台任务调度、数据驱动UI、异... 目录WorkManager工作原理最佳实践Data Binding工作原理进阶技巧Coroutine

如何通过Golang的container/list实现LRU缓存算法

《如何通过Golang的container/list实现LRU缓存算法》文章介绍了Go语言中container/list包实现的双向链表,并探讨了如何使用链表实现LRU缓存,LRU缓存通过维护一个双向... 目录力扣:146. LRU 缓存主要结构 List 和 Element常用方法1. 初始化链表2.

一文详解Nginx的强缓存和协商缓存

《一文详解Nginx的强缓存和协商缓存》这篇文章主要为大家详细介绍了Nginx中强缓存和协商缓存的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、强缓存(Strong Cache)1. 定义2. 响应头3. Nginx 配置示例4. 行为5. 适用场景二、协商缓存(协

Golang基于内存的键值存储缓存库go-cache

《Golang基于内存的键值存储缓存库go-cache》go-cache是一个内存中的key:valuestore/cache库,适用于单机应用程序,本文主要介绍了Golang基于内存的键值存储缓存库... 目录文档安装方法示例1示例2使用注意点优点缺点go-cache 和 Redis 缓存对比1)功能特性

Vue项目的甘特图组件之dhtmlx-gantt使用教程和实现效果展示(推荐)

《Vue项目的甘特图组件之dhtmlx-gantt使用教程和实现效果展示(推荐)》文章介绍了如何使用dhtmlx-gantt组件来实现公司的甘特图需求,并提供了一个简单的Vue组件示例,文章还分享了一... 目录一、首先 npm 安装插件二、创建一个vue组件三、业务页面内 引用自定义组件:四、dhtmlx

Vue ElementUI中Upload组件批量上传的实现代码

《VueElementUI中Upload组件批量上传的实现代码》ElementUI中Upload组件批量上传通过获取upload组件的DOM、文件、上传地址和数据,封装uploadFiles方法,使... ElementUI中Upload组件如何批量上传首先就是upload组件 <el-upl