官网
https://github.com/ben-manes/caffeine
wiki:
https://github.com/ben-manes/caffeine/wiki
概述
Caffeine是一个用于Java应用程序的高性能缓存框架。它提供了一个强大且易于使用的缓存库,可以在应用程序中使用,以提高数据访问的速度和效率。
下面是一些Caffeine缓存框架的主要特点:
-
高性能:Caffeine的设计目标之一是提供卓越的性能。它通过使用高效的数据结构和优化的算法来实现快速的缓存访问。与其他一些常见的缓存框架相比,Caffeine在缓存访问的速度和响应时间上表现出色。
-
内存管理:Caffeine提供了灵活的内存管理选项。它支持基于大小、基于数量和基于权重的缓存大小限制。你可以根据应用程序的需求来选择合适的缓存大小策略,并且可以通过配置参数进行进一步的调整。
-
强大的功能:Caffeine提供了许多强大的功能来满足各种需求。它支持异步加载和刷新缓存项,可以设置过期时间和定时刷新策略,支持缓存项的自动删除和手动失效等。此外,Caffeine还提供了统计信息和监听器机制,可以方便地监控和管理缓存的状态和变化。
-
线程安全:Caffeine是线程安全的,可以在多线程环境中安全地使用。它使用了细粒度的锁定机制来保护共享资源,确保并发访问的正确性和一致性。
-
易于集成:Caffeine是一个独立的Java库,可以很容易地与现有的应用程序集成。它与标准的Java并发库和其他第三方库兼容,并且可以与各种框架和技术(如Spring、Hibernate等)无缝集成。
Caffeine 是一个高性能的 Java 缓存框架,旨在提供快速、高效的内存缓存解决方案。它是由 Google 开发的,是 Guava 缓存的升级版。
Caffeine 的设计目标是提供高吞吐量、低延迟的缓存访问,并支持各种缓存策略和功能。以下是一些 Caffeine 框架的关键特点:
-
高性能:Caffeine 的设计优化了缓存的内存访问模式,使用了各种技术来减少缓存访问的开销,从而提高了性能。它使用了类似于 Java ConcurrentHashMap 的数据结构,支持并发访问,并提供了可配置的并发级别。
-
内存管理:Caffeine 提供了灵活的内存管理选项,可以通过设置缓存的最大大小、最大条目数或最大权重来控制缓存的大小。它还支持基于容量、时间或引用等策略来自动清理过期的缓存条目。
-
强大的缓存策略:Caffeine 提供了多种缓存策略,包括基于访问时间、写入时间或自定义规则的过期策略。它还支持最近最少使用(LRU)、最近最不常用(LFU)和固定大小等其他策略。
-
异步加载:Caffeine 支持异步加载缓存条目的功能。当缓存中不存在所需的条目时,它可以自动触发加载过程,并在加载完成后将结果放入缓存。
-
统计和监控:Caffeine 提供了丰富的统计和监控功能,可以跟踪缓存的命中率、加载时间、缓存大小等指标。这些信息对于调优和性能分析非常有用。
-
扩展性:Caffeine 的设计允许开发人员通过自定义策略、缓存加载器和监听器等扩展框架的功能。
使用 Caffeine 缓存框架非常简单。你可以通过以下步骤来开始使用:
-
引入 Caffeine 依赖:在你的项目中添加 Caffeine 的依赖项,可以通过 Maven、Gradle 或直接下载 JAR 文件进行引入。
-
创建缓存实例:使用 Caffeine 的构建器模式创建一个缓存实例,可以设置缓存的参数和策略。
-
存储和获取数据:使用缓存的
put
方法将数据存储到缓存中,使用get
方法从缓存中获取数据。如果缓存中不存在所需的数据,可以选择触发异步加载或提供自定义加载逻辑。 -
调优和配置:根据应用程序的需求,可以调整缓存的参数和策略,以获得最佳的性能和内存管理。
总之,Caffeine 是一个功能强大、高性能的 Java 缓存框架,适用于各种应用场景,尤其是需要快速访问、低延迟和高吞吐量的内存缓存需求。
设计
Code
POM
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<!-- Java 8 users can continue to use version 2.x, which will be supported -->
<version>2.9.3</version>
</dependency>
如果是caffeine 3.x的版本,需要JDK 11 以上。
Population
https://github.com/ben-manes/caffeine/wiki/Population
package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.AsyncLoadingCache;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import lombok.Builder;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
/**
* @author 小工匠
* @version 1.0
* @mark: show me the code , change the world
*/
@Slf4j
public class CaffeineBaseExampleWithJava {
@SneakyThrows
public static void main(String[] args) {
// initFirstWay();
// initSecondWay();
initThirdWay();
TimeUnit.SECONDS.sleep(10);
}
/**
* Cache手动创建
* <p>
* 最普通的一种缓存,无需指定加载方式,需要手动调用put()进行加载。需要注意的是put()方法对于已存在的key将进行覆盖,这点和Map的表现是一致的。
* 在获取缓存值时,如果想要在缓存值不存在时,原子地将值写入缓存,则可以调用get(key, k -> value)方法,该方法将避免写入竞争。调用invalidate()方法,将手动移除缓存。
* <p>
* 在多线程情况下,当使用get(key, k -> value)时,如果有另一个线程同时调用本方法进行竞争,则后一线程会被阻塞,直到前一线程更新缓存完成;
* 而若另一线程调用getIfPresent()方法,则会立即返回null,不会被阻塞。
*/
@SneakyThrows
public static void initFirstWay() {
Cache<Object, Object> cache = Caffeine.newBuilder()
//初始数量
.initialCapacity(10)
//最大条数
.maximumSize(10)
//expireAfterWrite和expireAfterAccess同时存在时,以expireAfterWrite为准
//最后一次写操作后经过指定时间过期
.expireAfterWrite(3, TimeUnit.SECONDS)
//最后一次读或写操作后经过指定时间过期
.expireAfterAccess(3, TimeUnit.SECONDS)
//监听缓存被移除
.removalListener((key, val, removalCause) -> {
log.info("listener remove : {} ,{} ,{}", key, val, removalCause);
})
//记录命中
.recordStats()
.build();
cache.put("name", "小工匠");
//小工匠
log.info((String) cache.getIfPresent("name"));
// 结合初始化的时候设置的过期时间, 模拟程序运行5秒后,再此获取
TimeUnit.SECONDS.sleep(5);
log.info("5秒后再次获取:{}", (String) cache.getIfPresent("name"));
//存储的是默认值
log.info((String) cache.get("noKey", o -> "默认值"));
}
/**
* Loading Cache自动创建
* <p>
* LoadingCache是一种自动加载的缓存。其和普通缓存不同的地方在于,当缓存不存在/缓存已过期时,若调用get()方法,则会自动调用CacheLoader.load()方法加载最新值。
* 调用getAll()方法将遍历所有的key调用get(),除非实现了CacheLoader.loadAll()方法。
* <p>
* 使用LoadingCache时,需要指定CacheLoader,并实现其中的load()方法供缓存缺失时自动加载。
* <p>
* 在多线程情况下,当两个线程同时调用get(),则后一线程将被阻塞,直至前一线程更新缓存完成。
*/
@SneakyThrows
public static void initSecondWay() {
Map<Integer, Artisan> map = getArtisanMap();
log.info("size:{}", map.size());
LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
//创建缓存或者最近一次更新缓存后经过指定时间间隔,刷新缓存;refreshAfterWrite仅支持LoadingCache
.refreshAfterWrite(10, TimeUnit.SECONDS)
.expireAfterWrite(10, TimeUnit.SECONDS)
.expireAfterAccess(10, TimeUnit.SECONDS)
.maximumSize(10)
//根据key查询数据库里面的值,这里是个lambda表达式
// TODO 根据其概况初始化 ,比如 build(userId -> getUserFromDatabase(userId));
// private User getUserFromDatabase(String userId) {
// // 这里会从数据库查询用户信息
// // ...
// return user;
// }
.build(key -> map.get(Integer.parseInt(key)).toString());
// 当执行get的时候,会触发 build 中的 lambda表达式
log.info(loadingCache.get("1"));
log.info(loadingCache.get("2"));
log.info(loadingCache.get("3"));
log.info(loadingCache.get("4"));
log.info(loadingCache.get("4", o -> "默认值"));
// 获取一个不存在的值
log.info(loadingCache.get("noKey", o -> "默认值"));
}
/**
* AsyncCache是Cache的一个变体,其响应结果均为CompletableFuture,
* 通过这种方式,AsyncCache对异步编程模式进行了适配。
* <p>
* 默认情况下,缓存计算使用ForkJoinPool.commonPool()作为线程池,如果想要指定线程池,则可以覆盖并实现Caffeine.executor(Executor)方法。
* <p>
* synchronous()提供了阻塞直到异步缓存生成完毕的能力,它将以Cache进行返回。
* <p>
* 在多线程情况下,当两个线程同时调用get(key, k -> value),则会返回同一个CompletableFuture对象。由于返回结果本身不进行阻塞,可以根据业务设计自行选择阻塞等待或者非阻塞。
*/
@SneakyThrows
public static void initThirdWay() {
Map<Integer, Artisan> map = getArtisanMap();
log.info("size:{}", map.size());
AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
//创建缓存或者最近一次更新缓存后经过指定时间间隔刷新缓存;仅支持LoadingCache
.refreshAfterWrite(1, TimeUnit.SECONDS)
.expireAfterWrite(1, TimeUnit.SECONDS)
.expireAfterAccess(1, TimeUnit.SECONDS)
.maximumSize(10)
//根据key查询数据库里面的值
.buildAsync(key -> {
Thread.sleep(1000);
return map.get(Integer.parseInt(key)).toString();
});
//异步缓存返回的是CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);
}
private static Map<Integer, Artisan> getArtisanMap() {
Map<Integer, Artisan> map = new HashMap<>(16);
map.put(1, Artisan.builder().id(1).name("artisan1").hobbies(Arrays.asList("Java")).build());
map.put(2, Artisan.builder().id(2).name("artisan2").hobbies(Arrays.asList("AIGC")).build());
map.put(3, Artisan.builder().id(3).name("artisan3").hobbies(Arrays.asList("HADOOP")).build());
map.put(4, Artisan.builder().id(4).name("artisan4").hobbies(Arrays.asList("GO")).build());
return map;
}
@Data
@Builder
private static class Artisan {
private Integer id;
private String name;
private List<String> hobbies;
}
}
expireAfterWrite和expireAfterAccess同时存在时,以expireAfterWrite为准
Eviction Policy
https://github.com/ben-manes/caffeine/wiki/Eviction
package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Scheduler;
import com.github.benmanes.caffeine.cache.Weigher;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
/**
* @author 小工匠
* @version 1.0
* @mark: show me the code , change the world
* @desc: 驱逐策略在创建缓存的时候进行指定。常用的有基于容量的驱逐和基于时间的驱逐。
* <p>
* 基于容量的驱逐需要指定缓存容量的最大值,当缓存容量达到最大时,Caffeine将使用LRU策略对缓存进行淘汰;基于时间的驱逐策略如字面意思,可以设置在最后访问/写入一个缓存经过指定时间后,自动进行淘汰。
* <p>
* 驱逐策略可以组合使用,任意驱逐策略生效后,该缓存条目即被驱逐。
* <p>
* LRU 最近最少使用,淘汰最长时间没有被使用的页面。
* LFU 最不经常使用,淘汰一段时间内使用次数最少的页面
* FIFO 先进先出
* Caffeine有4种缓存淘汰设置
* <p>
* 大小 (LFU算法进行淘汰)
* 权重 (大小与权重 只能二选一)
* 时间
* 引用
*/
@Slf4j
public class CaffeineEvictionPolicy {
/**
* 缓存大小淘汰
*/
@Test
public void maximumSizeTest() throws InterruptedException {
Cache<Integer, Integer> cache = Caffeine.newBuilder()
//超过10个后会使用W-TinyLFU算法进行淘汰
.maximumSize(10)
.evictionListener((key, val, removalCause) -> {
log.info("淘汰缓存:key:{} val:{}", key, val);
})
.build();
// 模拟写入数据
for (int i = 1; i < 20; i++) {
cache.put(i, i);
}
//缓存淘汰是异步的
Thread.sleep(1000);
// 打印还没被淘汰的缓存
log.info("未淘汰的缓存:{}", cache.asMap());
}
/**
* 权重淘汰
*/
@Test
public void maximumWeightTest() throws InterruptedException {
Cache<Integer, Integer> cache = Caffeine.newBuilder()
//限制总权重,若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
.maximumWeight(100)
.weigher((Weigher<Integer, Integer>) (key, value) -> key)
.evictionListener((key, val, removalCause) -> {
log.info("淘汰缓存:key:{} val:{}", key, val);
})
.build();
//总权重其实是=所有缓存的权重加起来
int maximumWeight = 0;
for (int i = 1; i < 20; i++) {
cache.put(i, i);
maximumWeight += i;
}
log.info("总权重={}", maximumWeight);
//缓存淘汰是异步的
Thread.sleep(1000);
// 打印还没被淘汰的缓存
log.info("未淘汰的缓存:{}", cache.asMap());
}
/**
* 访问后到期(每次访问都会重置时间,也就是说如果一直被访问就不会被淘汰)
*/
@Test
public void expireAfterAccessTest() throws InterruptedException {
Cache<Integer, Integer> cache = Caffeine.newBuilder()
.expireAfterAccess(1, TimeUnit.SECONDS)
//可以指定调度程序来及时删除过期缓存项,而不是等待Caffeine触发定期维护
//若不设置scheduler,则缓存会在下一次调用get的时候才会被动删除
.scheduler(Scheduler.systemScheduler())
.evictionListener((key, val, removalCause) -> {
log.info("淘汰缓存:key:{} val:{}", key, val);
})
.build();
cache.put(1, 2);
log.info("{}", cache.getIfPresent(1));
Thread.sleep(5000);
//null
log.info("{}", cache.getIfPresent(1));
Thread.sleep(500);
}
/**
* 写入后到期
*/
@Test
public void expireAfterWriteTest() throws InterruptedException {
Cache<Integer, Integer> cache = Caffeine.newBuilder()
.expireAfterWrite(1, TimeUnit.SECONDS)
//可以指定调度程序来及时删除过期缓存项,而不是等待Caffeine触发定期维护
//若不设置scheduler,则缓存会在下一次调用get的时候才会被动删除
.scheduler(Scheduler.systemScheduler())
.evictionListener((key, val, removalCause) -> {
log.info("淘汰缓存:key:{} val:{}", key, val);
})
.build();
cache.put(1, 2);
Thread.sleep(3000);
//null
log.info("{}", cache.getIfPresent(1));
}
}
Refresh
https://github.com/ben-manes/caffeine/wiki/Refresh
package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
/**
* @author 小工匠
* @version 1.0
* @mark: show me the code , change the world
* <p>
* <p>
* refreshAfterWrite()表示x秒后自动刷新缓存的策略可以配合淘汰策略使用,
* <p>
* 注意的是刷新机制只支持LoadingCache和AsyncLoadingCache
*/
@Slf4j
public class CaffeineRefreshPolicy {
private static int NUM = 0;
@Test
public void refreshAfterWriteTest() throws InterruptedException {
LoadingCache<Integer, Integer> cache = Caffeine.newBuilder()
.refreshAfterWrite(1, TimeUnit.SECONDS)
//模拟获取数据,每次获取就自增1
.build(integer -> ++NUM);
//获取ID=1的值,由于缓存里还没有,所以会自动放入缓存
// 返回结果 1
log.info("get value = {}", cache.get(1));
// 延迟2秒后,理论上自动刷新缓存后取到的值是2
// 但其实不是,值还是1,因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
// 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
Thread.sleep(2000);
// 返回结果 1
log.info("get value = {}", cache.getIfPresent(1));
//此时才会刷新缓存,而第一次拿到的还是旧值 ,这时候拿到的就是新的值了 2
// 返回结果2
log.info("get value = {}", cache.getIfPresent(1));
}
}
Statistics
https://github.com/ben-manes/caffeine/wiki/Statistics文章来源:https://www.toymoban.com/news/detail-564565.html
package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.Date;
import java.util.concurrent.TimeUnit;
/**
* @author 小工匠
* @version 1.0
* @mark: show me the code , change the world
*/
@Slf4j
public class CaffeineStatstic {
@Test
public void testStatistic() {
LoadingCache<String, String> cache = Caffeine.newBuilder()
//创建缓存或者最近一次更新缓存后经过指定时间间隔,刷新缓存;refreshAfterWrite仅支持LoadingCache
.refreshAfterWrite(1, TimeUnit.SECONDS)
.expireAfterWrite(1, TimeUnit.SECONDS)
.expireAfterAccess(1, TimeUnit.SECONDS)
.maximumSize(10)
//开启记录缓存命中率等信息
.recordStats()
//根据key查询数据库里面的值
.build(key -> {
Thread.sleep(1000);
return new Date().toString();
});
cache.put("1", "shawn");
cache.get("1");
/*
* hitCount :命中的次数
* missCount:未命中次数
* requestCount:请求次数
* hitRate:命中率
* missRate:丢失率
* loadSuccessCount:成功加载新值的次数
* loadExceptionCount:失败加载新值的次数
* totalLoadCount:总条数
* loadExceptionRate:失败加载新值的比率
* totalLoadTime:全部加载时间
* evictionCount:丢失的条数
*/
log.info("统计信息如下:\n {}", cache.stats());
}
}
文章来源地址https://www.toymoban.com/news/detail-564565.html
到了这里,关于缓存 - Caffeine 不完全指北的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!