JVM进程缓存Caffeine的使用

目录

• 一、前言
• 二、基本使用
• 2.1 手动创建缓存
• 2.2 异步获取缓存
• 2.3 记录命中数据
• 三、淘汰策略
• 3.2 最佳实践
• 四、配合Redis做二级缓存

一、前言

Caffeine是当前最优秀的内存缓存框架，不论读还是写的效率都远高于其他缓存，而且在Spring5开始的默认缓存实现就将Caffeine代替原来的Google Guava

二、基本使用

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

2.1 手动创建缓存

void test1() {
    Cache<Object, Object> cache = Caffeine.newBuilder()
            // 初始数量
            .initialCapacity(10)
            // 最大条数
            .maximumSize(10)
            // expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准
            // 最后一次写操作后经过指定时间过期
            .expireAfterWrite(1, TimeUnit.SECONDS)
            // 最后一次读或写操作后经过指定时间过期
            .expireAfterAccess(1, TimeUnit.SECONDS)
            // 监听缓存被移除
            .removalListener((key, value, cause) -> {})
            // 记录命中
            .recordStats()
            .build();
    cache.put("1", "张三");
    System.out.println(cache.asMap());
    System.out.println(cache.getIfPresent("1"));
    System.out.println(cache.get("2", o -> "默认值"));
}

运行结果

{1=张三}

张三

默认值

2.2 异步获取缓存

@Test
void test2() {
    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 new Date().toString();
            });
    // 异步缓存返回的是CompletableFuture
    CompletableFuture<String> future = asyncLoadingCache.get("1");
    future.thenAccept(System.out::println);
}

2.3 记录命中数据

@Test
void test3() {
  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 -> {
        TimeUnit.MILLISECONDS.sleep(1000);
        return new Date().toString();
      });

  cache.put("1", "小明");
  cache.get("1");

  /*
  * hitCount :命中的次数
  * missCount:未命中次数
  * requestCount:请求次数
  * hitRate:命中率
  * missRate:丢失率
  * loadSuccessCount:成功加载新值的次数
  * loadExceptionCount:失败加载新值的次数
  * totalLoadCount:总条数
  * loadExceptionRate:失败加载新值的比率
  * totalLoadTime:全部加载时间
  * evictionCount:丢失的条数
  */
  System.out.println(cache.stats());
}

会影响性能，生产环境下建议不开启

三、淘汰策略

• LRU: 最近最少使用，淘汰最长时间没有被使用的页面；
• LFU：最不经常使用，开发者_Python学习淘汰一段时间内，使用次数最少的页面；
• FIFO：先进先出

LRU的优点：LRU相比于LFU而言性能更好一些，因为它算法相对比较简单，不需要记录访问频次，可以更好地应对突发流量；

LRU的缺点：虽然性能好一些，但是它通过历史数据来预测未来是局限的，它会认为最后到来的数据是最可能被再次访问的，从而给与它最高的优先级。有些非热点数据被访问过后，占据了高优先级，它会在缓存中占据相当长的时间，从而造成空间浪费；

LFU的优点：LRU根据访问频次访问，在大部分情况下，热点数据的频次肯定高于非热点数据，所以它的命中率非常高；

LFU的缺点：LFU算法相对比较复杂，性能比LRU差。有问题的是下面这种情况，比如前一段时间微博有个热点话题热度非常高，就比如那种可以让微博短时间停止服务的，于是赶紧缓存起来，LFU算法记录了其中热点词的访问频率，可能高达十几亿，而过后很长一段时间，这个话题已经不是热点了，新的热点也来了，但是，新热点话题的热度没办法到达十几亿，也就是说访问频次没有之前的话提高，那之前的热点就会一直占据着缓存空间，长时间无法被剔除。

3.1 4种淘汰方式与例子

Caffeine有4种缓存淘汰设置

• 大小（会使用W-TinyLFU算法进行淘汰）
• 权重（大小与权重，只能二选一）
• 时间
• 引用（不常用）

// 缓存大小淘汰
@Test
public void maximumSizeTest() throws InterruptedException {
  Cache<Object, Object> cache = Caffeine.newBuilder()
      // 超过10个后会使用W-TinyLFU算法进行淘汰
      .maximumSize(10)
      .build();
  for (int i = 1; i <= 10; i++) {
    cache.put(i, i);
  }
  // 缓存淘汰是异步的
  TimeUnit.MILLISECONDS.sleep(500);
  // 打印还没有被淘汰的缓存
  System.out.println(cache.asMap());
}

// 权重淘汰
@Test
public void maximumWeightTest() throws InterruptedException {
  Cache<Integer, Integer> cache = Caffeine.newBuilder()
      // 限制总权值，若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
      .maximumWeight(100)
      .weigher((Weigher<Integer, Integer>) (key, value) -> key)
      .build();
  // 总权重其实是=所有缓存的权重加起来
  int maximumWeight = 0;
  for (int i = 1; i < 20; i++) {
    cache.put(i, i);
    maximumWeight += i;
    System.out.println("i = " + i + ", maximumWeight = " + maximumWeight);
  }
  System.out.println("总权重 = " + maximumWeight);
  // 缓存淘汰是异步的
  TimeUnit.MILLISECONDS.sleep(500);
  // 打印还没有被淘汰的缓存
  System.out.println(cache.asMap());
}

// 访问后到期（每次访问都会重置时间，也就是说如果一直被访问就不会被淘汰）
@Test
void expireAfterAccessTest() throws InterruptedException {
  Cache<Object, Object> cache = Caffeine.newBuilder()
      .expireAfterAccess(1, TimeUnit.SECONDS)
      // 可以指定调度程序android来及时删除过期缓存项，而不是等待Caffeine触发定期维护
      // 若不设置scheduler,则缓存会在下一次调用get的时候才会被动删除
      .scheduler(Scheduler.systemScjavascriptheduler())
      .build();
  cache.put(1, 2);
  System.out.println(cache.getIfPresent(1));
  Thread.sleep(3000);
  System.out.println(cache.getIfPresent(1));
}

// 写入后到期
@Test
void expireAfterWriteTest() throws InterruptedException {
  Cache<Object, Object> cache = Caffeine.newBuilder()
      .expireAfterWrite(1, TimeUnit.SECONDS)
      // 可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
      // 若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
      .scheduler(Scheduler.systemScheduler())
      .build();
  cache.put(1, 2);
  TimeUnit.MILLISECONDS.sleep(3000);
  System.out.println(cache.getIfPresent(1));
}

另外还有一个refreshAfterWrite()表示x秒后自动刷新缓存可以配合以上的策略使用

// 另外还有一个refreshAfterWrite()表示x秒后自动刷新缓存可以配合以上的策略使用
  private static int num = 0;
@Test
void refreshAfterWriteTest() throws InterruptedException {
  LoadingCache<Object, Integer> cache = Caffeine.newBuilder()
      .refreshAfterWrite(1, TimeUnit.SECONDS)
      .build(integer -> ++num);

  // 获取ID=1的值，由于缓存里还没有，所以会自动放入缓存
  System.out.println(cache.get(1));

  // 延迟2秒后，理论上自动刷新缓存后取到的值是2
  // 但其实不是，值还是1，因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
  // 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
  Thread.sleep(2000);
  System.out.println(cache.getIfPresent(1));// 1

  //此时才会刷新缓存，而第一次拿到的还是旧值
  System.out.println(cache.getIfPresent(1));// 2
}

3.2 最佳实践

实践1

• 配置：设置maxSize、refreshAfterWrite，不设置expireAfterWrite/expireAfterAccess
• 优缺点：因为设置expireAfterWrite当缓存过期会同步加锁获取缓存，所以设置expireAfte编程客栈rWrite时性能较好，但是js某些时候会取旧数据，适合允许取到旧数据的场景

实践2

• 配置：设置maxSize、expireAfterWrite/expireAfterAccess，不设置refreshAfterWrite
• 优缺点：与上面相反，数据一致性好，不会获取到旧数据，但是性能没那么好，适合获取数据时不耗时的场景

四、配合Redis做二级缓存

缓存的解决方案一般有三种：

• 本地内存缓存，如Caffeine、Ehcache；适合单机系统，速度最快，但是容量有限，而且重启系统后缓存丢失；
• 集中式缓存，如Redis、Memcached；适合分布式系统，解决了容量、重启丢失缓存等问题，但是当访问量极大时，往往性能不是首要考虑的问题，而是带宽。现象就是Redis服务负载不高，但是由于机器网卡带宽跑满，导致数据读python取非常慢；
• 第三种方案就是结合以上2种方案的二级缓存应运而生，以内存缓存作为一级缓存、集中式缓存作为二级缓存

到此这篇关于JVM进程缓存Caffeine的使用的文章就介绍到这了,更多相关JVM进程缓存Caffeine内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！