Caffeine入门使用

已于 2022-04-20 09:43:42 修改
阅读量1.5w 收藏 71
点赞数 9
分类专栏： caffeine 文章标签： 缓存
于 2020-09-08 10:22:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_dongyang/article/details/108326755
版权

《Caffeine入门使用》 -> 《Caffeine基础源码解析》 -> 《Caffeine 驱逐算法》

一、概况

就一般的互联网行业中的应用而言，目前比较通用的并且也是普遍存在的一个应用工作过程，如下图所示：用户从浏览器发出请求-网络转发-应用服务业务处理-底层存储信息获取，然后逆向的返回给用户，形成页面给予用户相应信息。
在这里插入图片描述
随着业务的上升，用户量的增加，访问量也会随之增加，如果是计算型的服务，那么对于服务器的计算能力是一个考验，如果是IO型的服务，那么频繁的从文件系统、数据库等磁盘文件获取信息会造成比较大的延时且压力也比较大。因为我们的服务资源是有限的，并且技术革新也不是很迅速，那么我们如何利用有限的服务资源支撑更大的吞吐量呢？业界内很常见的一个普遍方案就是引进缓存，将计算结果、磁盘文件结果信息缓存于内存之中，那么上图中每个环节都可以从缓存中直接获取所需信息，减少应用服务器的压力，也就是通过减少磁盘读取、数据计算等方式来快速获取所需结果，提高相应速度。

当我们提到缓存的时候，第一时间就会想到Redis、memcached缓存中间件，他们支持分布式的缓存，还有一种是基于单机内存的缓存方式，例如最简单的java中的局部变量、java中的ConcurrentHashMap、谷歌发布的Guava cache组件以及本文讲解的Caffeine cache，他们将缓存信息存储于应用本身的内存之中，业务可以缓存组件的API去操作内存中的缓存数据。

简介

Caffeine是一款基于jdk8实现的缓存工具，在设计上参考了google的Guava cach组件，可以理解为是一个GuavaCache的加强版本，性能也是在其基础上有了提升。

Caffeine cache的作者是Ben manes，可以通过他的github：github.com/ben-manes来查看组件的源码 ，并且他还编写了ConcurrentLinkedHashMap工具类，也被用于缓存的底层数据结构，比如：这个类就是Guava cache的基础。我们知道Guava cache是基于LRU算法实现的一种缓存工具，LRU算法的缺点是短暂持续性冷数据流量会导致热数据的淘汰，造成数据的污染。而Caffeine cache采用了在LRU基础上的W-TinyLFU算法实现，有比较好的命中率。

优点

Caffeine淘汰算法：使用基于W-TinyLFU算法，实现几乎完美的命中率；

  1. FIFO：实现简单，类似于队列，先进先出，因此缓存命中率不是很高。

  2. LRU：最近最久未使用算法（Least Recently Used）如果一个数据在一段时间内没有被访问，那么我们认为后面被访问的概率也很小。当我们添加新数据的时候，会把新数据放到队尾（假设新数据最大概率被再次访问），当我们长度到达阈值需要淘汰数据的时候，会从队首进行淘汰。这种算法造成缓存污染的概率会大些，比如现在有一些较少数据突增流量，但是后面不在访问，那么此时已经将热数据淘汰出去了，而缓存的数据后面也几乎不被访问。

  3. LFU：最近最少使用算法（Least Frequently Used）如果一个数据在一段时间内访问的频率很小，那么认为后面被访问的几率也很小，所以淘汰访问频率最少的数据；该算法可以处理LRU因为冷数据突增带来的缓存污染问题。存在的问题是数据访问模式如果改变，这种算法命中率会下降，并且需要额外的空间存储信息频率。

  4. W-TinyLFU：记录了近期访问记录的频率信息，不满足的记录不会进入到缓存。使用Count-Min Sketch算法记录访问记录的频率信息。依靠衰减操作，来尽可能的支持数据访问模式的变化。
    在这里插入图片描述
    该算法和布隆过滤器有着相似的原理，通过多个哈希函数和位的标志来表示一个结果，可以通过结合布隆过滤器一起理解这个算法。一些常用的页面置换算法可参考文章《缓存算法》

适用场景

因为Caffeine cache是类似于Guava cache的一种内存缓存，所以适合单机的数据缓存；因为存储在内存的，没有持久化，因此适合一些短期或者启动以及结果信息的短暂缓存。当涉及到多机多服务的缓存时候，属于分布式缓存的范畴，可以使用Redis、memcached等分布式的缓存组件。

二、使用

因为是基于Guava cache实现的，因此二者的API大体是类似的，使用Guava cache的开发者可以很快熟练使用Caffeine cache。

坐标

目前Caffeine的最新版是2.8.5版本，本文使用的是2.8.0版本

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.8.0</version>
</dependency>

缓存填充策略

缓存的填充方式有三种，手动、同步和异步，下面分别简单介绍下每种方式使用的API：

  1. 手动加载：手动控制缓存的增删改处理，主动增加、获取以及依据函数式更新缓存；底层使用ConcurrentHashMap进行节点存储，因此get()方法是安全的。批量查找可以使用getAllPresent()方法或者带填充默认值的getAll()方法。
    /**
     * 手动填充测试
     */
    public void cacheTest(String k) {
        Cache<String, String> cache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterAccess(100L, TimeUnit.SECONDS)
                .build();

        cache.put("c1", "c1");
        //获取缓存值，如果为空，返回null
        log.info("cacheTest present： [{}] -> [{}]", k, cache.getIfPresent(k));
        //获取返回值，如果为空，则运行后面表达式，存入该缓存
        log.info("cacheTest default： [{}] -> [{}]", k, cache.get(k, this::buildLoader));
        log.info("cacheTest present： [{}] -> [{}]", k, cache.getIfPresent(k));
        //清除缓存
        cache.invalidate(k);
        log.info("cacheTest present： [{}] -> [{}]", k, cache.getIfPresent(k));
    }
    private String buildLoader(String k) {
        return k + "+default";
    }
  1. 同步加载：LoadingCache对象进行缓存的操作，使用CacheLoader进行缓存存储管理。批量查找可以使用getAll()方法。默认情况下，getAll()将会对缓存中没有值的key分别调用CacheLoader.load方法来构建缓存的值（build中的表达式）。我们可以重写CacheLoader.loadAll方法来提高getAll()的效率。
    /**
     * 同步填充测试
     */
    public void loadingCacheTest(String k) {
        //同步填充在build方法指定表达式
        LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterAccess(100L, TimeUnit.SECONDS)
                .build(this::buildLoader);
        
        loadingCache.put("c1", "c1");
        log.info("loadingCacheTest get： [{}] -> [{}]", k, loadingCache.get(k));
        //获取缓存值，如果为空，返回null
        log.info("loadingCacheTest present： [{}] -> [{}]", k, loadingCache.getIfPresent(k));
        //获取返回值，如果为空，则运行后面表达式，存入该缓存
        log.info("loadingCacheTest default： [{}] -> [{}]", k, loadingCache.get(k, this::buildLoader));
        log.info("loadingCacheTest present： [{}] -> [{}]", k, loadingCache.getIfPresent(k));
        loadingCache.invalidate(k);
        log.info("loadingCacheTest present： [{}] -> [{}]", k, loadingCache.getIfPresent(k));
    }
    private String buildLoader(String k) {
        return k + "+default";
    }
  1. 异步加载：
    自动异步加载：
    AsyncLoadingCache对象进行缓存管理，get()返回一个CompletableFuture对象，默认使用ForkJoinPool.commonPool()来执行异步线程，但是我们可以通过Caffeine.executor(Executor) 方法来替换线程池。
    /**
     * 异步填充测试
     */
    public void asyncLoadingCacheTest(String k) throws ExecutionException, InterruptedException {
        //异步加载使用Executor去调用方法并返回一个CompletableFuture。异步加载缓存使用了响应式编程模型。
        //
        //如果要以同步方式调用时，应提供CacheLoader。要以异步表示时，应该提供一个AsyncCacheLoader，并返回一个CompletableFuture。
        AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterAccess(100L, TimeUnit.SECONDS)
                .buildAsync(s -> this.buildLoaderAsync("123").get());

        log.info("asyncLoadingCacheTest get： [{}] -> [{}]", k, asyncLoadingCache.get(k).get());
        //获取返回值，如果为空，则运行后面表达式，存入该缓存
        log.info("asyncLoadingCacheTest default： [{}] -> [{}]", k, asyncLoadingCache.get(k, this::buildLoader).get());
    }

    private CompletableFuture<String> buildLoaderAsync(String k) {
        return CompletableFuture.supplyAsync(() -> k + "+buildLoaderAsync");
    }

手动异步加载：

    /**
     * 手动异步测试
     */
    public void asyncManualCacheTest(String k) throws ExecutionException, InterruptedException {
        //异步加载使用Executor去调用方法并返回一个CompletableFuture。异步加载缓存使用了响应式编程模型。
        //
        //如果要以同步方式调用时，应提供CacheLoader。要以异步表示时，应该提供一个AsyncCacheLoader，并返回一个CompletableFuture。
        AsyncCache<String, String> asyncCache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterAccess(100L, TimeUnit.SECONDS)
                .buildAsync();
        //获取返回值，如果为空，则运行后面表达式，存入该缓存
        log.info("asyncManualCacheTest default： [{}] -> [{}]", k, asyncCache.get(k, this::buildLoader).get());
    }

过期策略

Caffeine的缓存清除是惰性的，可能发生在读请求后或者写请求后，比如说有一条数据过期后，不会立即删除，可能在下一次读/写操作后触发删除（类比于redis的惰性删除）。如果读请求和写请求比较少，但想要尽快的删掉cache中过期的数据的话，可以通过增加定时器的方法，定时执行cache.cleanUp()方法（异步方法，可以等待执行），触发缓存清除操作。

  1. 基于大小过期：当缓存超出后，使用W-TinyLFU算法进行缓存淘汰处理
  • 基于缓存条目过期
    maximumSize()方法，参数是缓存中存储的最大缓存条目，当添加缓存时达到条目阈值后，将进行缓存淘汰操作
    /**
     * 淘汰策略-size
     */
    public void sizeTest() {
        LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
                .maximumSize(1)
                .build(this::buildLoader);

        List<String> list = Lists.newArrayList("c1", "c2", "c3");
        loadingCache.put(list.get(0), list.get(0));
        log.info("weightTest get： [{}] -> [{}]", list.get(0), loadingCache.get(list.get(0)));
        loadingCache.put(list.get(1), list.get(1));
        log.info("weightTest get： [{}] -> [{}]", list.get(1), loadingCache.get(list.get(1)));
        loadingCache.put(list.get(2), list.get(2));
        log.info("weightTest get： [{}] -> [{}]", list.get(2), loadingCache.get(list.get(2)));
        log.info("weightTest cache map：{}", loadingCache.getAll(list));
    }
  • 基于权重过期：权重大小不会决定缓存满时清楚的优先级
    weigher()方法可以指定缓存所占比重，maximumWeight()方法指定最大的权重阈值，当添加缓存超过规定权重后，进行数据淘汰
    /**
     * 淘汰策略-weight
     */
    public void weightTest() {
        LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
                .maximumWeight(10)
                .weigher((key, value) -> 5)
                .build(this::buildLoader);

        List<String> list = Lists.newArrayList("c1", "c2", "c3");
        loadingCache.put(list.get(0), list.get(0));
        log.info("weightTest get： [{}] -> [{}]", list.get(0), loadingCache.get(list.get(0)));
        loadingCache.put(list.get(1), list.get(1));
        log.info("weightTest get： [{}] -> [{}]", list.get(1), loadingCache.get(list.get(1)));
        log.info("weightTest cache map：{}", loadingCache.getAll(list));
    }
  1. 基于时间过期
  • expireAfterAccess()：缓存访问后，一定时间失效；即最后一次访问或者写入开始时计时。
  • expireAfterWrite()：缓存写入后，一定时间失效；以写入缓存操作为准计时。
  • expireAfter()：自定义缓存策略，满足多样化的过期时间要求。
    /**
     * 淘汰策略-time
     */
    public void timeTest() {
        //1.缓存访问后，一定时间后失效
        LoadingCache<String, String> loadingCacheOne = Caffeine.newBuilder()
                .expireAfterAccess(10L, TimeUnit.SECONDS)
                .build(this::buildLoader);

        //2.缓存写入后，一定时间后失效
        LoadingCache<String, String> loadingCacheTwo = Caffeine.newBuilder()
                .expireAfterWrite(10L, TimeUnit.SECONDS)
                .build(this::buildLoader);

        //3.自定义过期策略
        LoadingCache<String, String> loadingCacheThree = Caffeine.newBuilder()
                .expireAfter(new Expiry<Object, Object>() {
                    @Override
                    public long expireAfterCreate(@NonNull Object o, @NonNull Object o2, long l) {
                        return 0;
                    }

                    @Override
                    public long expireAfterUpdate(@NonNull Object o, @NonNull Object o2, long l, @NonNegative long l1) {
                        return 0;
                    }
                    @Override
                    public long expireAfterRead(@NonNull Object o, @NonNull Object o2, long l, @NonNegative long l1) {
                        return 0;
                    }
                })
                .build(this::buildLoader);
    }
  1. 基于引用过期
引用名称垃圾回收时机用途生存周期
强引用（Strong Reference）不回收正常普遍的类别JVM停止运行
软引用（soft Reference）内存不足回收缓存对象内存不足时
弱引用（weak Reference）下一次GC回收缓存对象GC之后
虚引用（Phantom Reference）随时回收，引用虚设通知功能随时回收
下面展示了API使用方式：
    /**
     * 淘汰策略-引用
     */
    public void referenceTest() {
        //1.弱引用弱key方式，没有强引用时，回收
        LoadingCache<String, String> loadingCacheOne = Caffeine.newBuilder()
                .weakKeys()
                .weakValues()
                .build(this::buildLoader);

        //2.软值引用，内存不足的时候回收
        LoadingCache<String, String> loadingCacheTwo = Caffeine.newBuilder()
                .softValues()
                .build(this::buildLoader);
    }
  • Caffeine.weakKeys()：使用弱引用存储key，当没有其他的强引用时，则会被垃圾回收器回收；
  • Caffeine.weakValues()：使用弱引用存储value，当没有其他的强引用时，则会被垃圾回收器回收；
  • Caffeine.softValues()：使用软引用存储key，当没有其他的强引用时，内存不足的时候会被回收；
    注：Weak or soft values can not be combined with AsyncCache

手动删除

Caffeine中提供了手动进行缓存的删除，无需等待我们上面提到的被动的一些删除策略，使用方法如下：

    cacheOne.invalidateAll();
    cacheOne.invalidate(Object o);
    cacheOne.invalidateAll(List);

事件监听

移除事件RemovalListener是一种缓存监听事件，当key被移除的时候就会触发这个方法，可以进行一些相关联的操作。RemovalListener可以获取到key、value和RemovalCause（删除的原因）。另外RemovalListener中操作是线程池异步执行的。

    /**
     * 移除监听器
     */
    public void removeTest() throws InterruptedException {
        Cache<String, String> cacheOne = Caffeine.newBuilder()
                .maximumSize(1)
                .removalListener(
                (o, o2, removalCause) -> 
                System.out.println(o + " is " + "remove" + " reason is " + removalCause.name()))
                .build();
    }

外部存储

CacheWriter是实现Caffeine cache的实现外部资源操作的一种方式，所有缓存的读写可以通过CacheWriter进行传递，比如我们可以通过CacheWriter的实现方法进行第三方外部资源的操作。一方面这个组件可以代替上面提到的RemovalListener移除事件监听，不同之处在于这个是同步执行的，且是一个原子操作，写入缓存完成之前会阻塞后续更新缓存的操作，但是读缓存不会阻塞；另一方面，可以当作是维持和外部资源的一个纽带，进行外部资源关联使用。

    /**
     * writer
     */
    public void writerTest() {
        Cache<String, String> cacheOne = Caffeine.newBuilder()
                .maximumSize(1)
                .writer(new CacheWriter<Object, Object>() {
                    @Override
                    public void write(@NonNull Object o, @NonNull Object o2) {
                        System.out.printf("key: %s is write , value: %s", o, o2);
                    }

                    @Override
                    public void delete(@NonNull Object o, @Nullable Object o2, @NonNull RemovalCause removalCause) {
                        System.out.printf("key: %s is delete , value: %s , reason is %s", o, o2, removalCause.name());
                    }
                })
                .build();
        cacheOne.put("k1", "v1");
        System.out.printf("key: %s , value: %s", "k1", cacheOne.getIfPresent("k1"));
        cacheOne.put("k2", "v2");
        System.out.printf("key: %s , value: %s", "k1", cacheOne.getAllPresent(Lists.newArrayList("k1", "k2")));
    }

Springboot集成

spring从3的版本开始支持Cache的处理，使用方式也是按照传统方向提供两种，基于注解和基于xml配置文件的方式，其操作纬度为方法或类，比如将注解@Cacheable按要求配置到一个方法上，会构造出一个k-v的缓存信息，k是入参相关，value就是方法的返回值，当请求到这个方法上，先去缓存获取，有则直接返回，无则执行流程然后返回且存入缓存。还有一些其他的注解，例如：@CachePut、@CacheEvict等。

Springboot中的spring cache是可以直接整合Caffeine cache的，配置的步骤大概就是：

  1. 声明spring对cache的支持
  2. 方法配置缓存使用

注解方式

yml文件配置：

spring:
  cache:
    type: caffeine
    cache-names:
      - caffeineTestOne
      - caffeineTestTwo
    caffeine:
      spec: maximumSize=500

在启动类加注解：@EnableCaching，表示开始缓存功能

@EnableCaching
@EnableOpenApi
@SpringBootApplication
@ComponentScan(basePackages = "com.ldy")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

在想要缓存的方法和参数上使用注解：@Cacheable(value = “caffeineTestOne”)（value指定了caffeine）

    @Cacheable(value = "caffeineTestOne")
    public String getKey(String key) {
        log.info("本次从逻辑获取 key=[{}]", key);
        return key;
    }

执行第一次显示日志，表示从逻辑中获取，后面的同参数请求就没日志打印了，表示走的是Caffeine缓存。

配置文件的方式比较死板，这里不做演示，感兴趣的可以自己在本地尝试下。

三、参考文档

[1]：源码 github.com/ben-manes
[2]：https://tech.meituan.com/2017/03/17/cache-about.html

Ftsom
关注
  • 9
    点赞
  • 踩
  • 71
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Caffeine （史上最全）
架构师尼恩
02-08 3万+
备注： 文章很长，建议收藏起来，慢慢读! 并且，持续更新中… 架构师 尼恩 为您推荐 高薪必备 ： 《Netty Zookeeper Redis 高并发实战》 为你打造NIO、Netty 高性能底层原理知识底座 高薪必备 ： 《SpringCloud、Nginx高并发核心编程》 为你打造微服务、分布式 高并发底层原理知识底座 高薪必备 ：价值 1000元网盘资源大礼包，免费拿 【博客园总入口 】 Caffeine简介 在本文中，我们来看看 Caffeine — 一个高性能的 Java
Caffeine缓存 最快缓存 内存缓存
Java知识图谱的博客
01-21 4014
一、序言 Caffeine是一个进程内部缓存框架。 对比Guava Cache Caffeine是在Guava Cache的基础上做一层封装，性能有明显提高，二者同属于内存级本地缓存。使用Caffeine后无需使用Guava Cache，从并发的角度来讲，Caffeine明显优于Guava，原因是使用了Java 8最新的StampedLock锁技术。 二、缓存简介 （一）缓存对比 从横向对常用的缓存进行对比，有助于加深对缓存的理解，有助于提高技术选型的合理性。下面对比三种常用缓存：Redis、EhCach.
springboot本地缓存caffeine使用
2401_84511008的博客
05-14 161
springboot项目,本地缓存Caffeine。
本地缓存天花板-Caffeine
weixin_37799575的博客
12-30 3552
Caffeine是一个基于Java8开发的提供了近乎最佳命中率的高性能的缓存库。 缓存和ConcurrentMap有点相似，但还是有所区别。最根本的区别是ConcurrentMap将会持有所有加入到缓存当中的元素，直到它们被从缓存当中手动移除。但是，Caffeine的缓存Cache 通常会被配置成自动驱逐缓存中元素，以限制其内存占用。在某些场景下，LoadingCache和AsyncLoadingCache 因为其自动加载缓存的能力将会变得非常实用。
Caffeine Cache-高性能Java本地缓存组件
竹林幽深
02-15 743
https://mp.weixin.qq.com/s/m8DwlimtJs8ezl5hOXj37w
SpringBoot 使用 Caffeine 本地缓存
johnhuster的专栏
02-15 3311
一、本地缓存介绍 . 二、缓存组件 Caffeine 介绍 . 1、Caffeine 性能 . 2、Caffeine 配置说明 . 3、软引用与弱引用 . 三、SpringBoot 集成 Caffeine 两种方式 . 四、SpringBoot 集成 Caffeine 方式一 . 1、Maven 引入相关依赖 . 2、配置缓存配置类 . 3、定义测试的实体对象 . 4、定义服务...
java编程之Caffeine缓存
12-16
# java编程之Caffeine缓存 # 简介 Caffeine是本地缓存，也就是和本机内存交互，读取和存入缓存在本机内存 缓存包括本地缓存和分部署缓存，对于本地缓存而言，不需要考虑集群问题，因为本地缓存就是指服务器的缓存。 ...
Caffeine本地缓存
04-27
1. **直接使用Caffeine API**：引入Caffeine依赖，然后通过Caffeine的Builder模式创建并配置缓存实例。 2. **结合Spring Cache**：引入Caffeine和Spring Cache的依赖，利用Spring的注解机制简化缓存操作。 在pom....
mac 不待机caffeine
10-26
Caffeine for mac中文名字叫做——咖啡因，这是一款很有用的小工具。caffeine for mac可以让你的 Mac 屏幕保持点亮状态，不会因时间的问题进入休眠状态。
Spring Boot缓存实战 Caffeine示例
08-27
概述：本文介绍了使用 Spring Boot 实现缓存实战的示例，使用 Caffeine 作为缓存框架。Caffeine 是一个使用 Java 8 重写的 Guava 缓存版本，在 Spring Boot 2.0 中将取代 Guava。 一、Caffeine 简介 Caffeine 是一...
caffeine-2.9.3.jar
12-12
caffeine-2.9.3.jar
java: 无法访问com.github.benmanes.caffeine.cache.CacheLoader
weixin_43467561的博客
11-02 3188
去java jdk官网去下载一个更高版本的jdk 进行安装 之前的jdk版本不用删除 把先下载的放在另一个文件夹就可以。还有就是控制面板里的高级设置里的环境配置JAVA_HOME的地址修改成存放jdk的文件夹。然后在idea 项目结构里。在这里添加下载好的jdk。
Caffeine简单的使用
tianxing1236的博客
01-19 778
Caffeine简单的使用 package cache; import com.github.benmanes.caffeine.cache.Cache; import com.github.benmanes.caffeine.cache.CacheLoader; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.RemovalListener; import org.
Caffeine
korn的博客
11-26 1782
Caffeine简单总结
Caffeine本地缓存详解（一篇就明白）
热门推荐
dgh112233的博客
07-21 2万+
结论：Caffeine 是目前性能最好的本地缓存，因此，在考虑使用本地缓存时，直接选择 Caffeine 即可。 先看一个小例子，明白如何创建一个 Caffeine 缓存实例。 Caffeine caffeine = Caffeine.newBuilder() .initialCapacity(3) .maximumSize(4); Cache cache = caffeine.build(); cache.
本地缓存王者，Caffeine 保姆级教程！给力...
公众号-老炮说Java
07-11 1273
缓存(Cache)在代码世界中无处不在。从底层的CPU多级缓存，到客户端的页面缓存，处处都存在着缓存的身影。缓存从本质上来说，是一种空间换时间的手段，通过对数据进行一定的空间安排，使得下次进行数据访问时起到加速的效果。就Java而言，其常用的缓存解决方案有很多，例如数据库缓存框架EhCache，分布式缓存Memcached等，这些缓存方案实际上都是为了提升吞吐效率，避免持久层压力过大。对于常见缓存...
caffeine cache
ZERO
04-15 2517
转载自：https://blog.csdn.net/rlnLo2pNEfx9c/article/details/85241639   guava cache的功能的确是很强大，满足了绝大多数的人的需求，但是其本质上还是LRU的一层封装,所以在众多其他较为优良的淘汰算法中就相形见绌了。而caffeine cache实现了W-TinyLFU(LFU+LRU算法的变种)。W-TinyLFU是命中率最接近...
缓存之王Caffeine Cache，性能比Guava更强，命中率更高
Java搜索工程技术栈
06-20 830
在项目开发中，为提升系统性能，减少 IO 开销，本地缓存是必不可少的。最常见的本地缓存是 Guava 和 Caffeine，本篇文章将为大家介绍 Caffeine。Caffeine 是基于 Google Guava Cache 设计经验改进的结果，相较于 Guava 在性能和命中率上更具有效率，你可以认为其是 Guava Plus。毋庸置疑的，你应该尽快将你的本地缓存从 Guava 迁移至 Caffeine，本文将重点和 Guava 对比二者性能占据，给出本地缓存的最佳实践，以及迁移策略。从功能上看，Gua
本地缓存之王，Caffeine保姆级教程
竹林幽深
05-17 395
缓存(Cache)在代码世界中无处不在。从底层的CPU多级缓存，到客户端的页面缓存，处处都存在着缓存的身影。缓存从本质上来说，是一种空间换时间的手段，通过对数据进行一定的空间安排，使得下次进行数据访问时起到加速的效果。就Java而言，其常用的缓存解决方案有很多，例如数据库缓存框架EhCache，分布式缓存Memcached等，这些缓存方案实际上都是为了提升吞吐效率，避免持久层压力过大。
caffeine 使用
最新发布
05-31
Caffeine是一种常用的中枢神经系统刺激剂，它可以帮助人们保持清醒和注意力。Caffeine主要存在于咖啡、茶叶、可可和一些软饮料中。当人们摄入咖啡因后，它会刺激大脑中的多巴胺神经元，使得人们感到提神、兴奋和注意力集中。 此外，Caffeine还具有一定的药理作用。它可以通过扩张血管，促进心肌收缩和增加心率等方式，起到一定的心血管刺激作用。适量的摄入Caffeine对健康有益，但是过量摄入可能会导致心悸、失眠、胃肠不适等不良反应。 如果您想使用Caffeine提高注意力和工作效率，请注意适量摄入，并结合自己的身体状况进行调整。同时，也要注意Caffeine的来源和摄入时间，以免影响睡眠和健康。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值