内存缓存-caffeine

最新推荐文章于 2024-06-15 18:46:15 发布
最新推荐文章于 2024-06-15 18:46:15 发布
阅读量877 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35930102/article/details/113772317
版权

1 快速入门案例

maven依赖

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

1.1 构建cache工具类

public enum LoadTypeEnum {
    /**
     * 手动加载
     */
    MANUAL,

    /**
     * 同步加载
     */
    SYNC,

    /**
     * 异步加载
     */
    ASYNC,

    /**
     * 后台刷新
     */
    REFRESH
}

@Slf4j
public class CacheUtil {

    private static final Random RANDOM = new Random();

    private static ExecutorService executorService = Executors.newCachedThreadPool();

    public static int randomInt() {
        return RANDOM.nextInt(1000);
    }

    public static void execute(Runnable runnable) {
        executorService.execute(runnable);
    }

    public static LoadingCache buildLoadCache(CacheConfig config) {
        return (LoadingCache) buildLoadCache(LoadTypeEnum.REFRESH, config.getInitialCapacity(), config.getMaximumSize());
    }

    public static Object buildLoadCache(LoadTypeEnum loadTypeEnum) {
        return buildLoadCache(loadTypeEnum, 10, 100);
    }

    private static Object buildLoadCache(LoadTypeEnum loadTypeEnum, int initialCapacity, int maximumSize) {
        Caffeine<String, Object> caffeine = Caffeine.newBuilder()
                // 初始容量
                .initialCapacity(initialCapacity)
                // 最大容量为（基于容量进行回收）
                .maximumSize(maximumSize)
                // 监控
                .recordStats()
                //当Entry被移除时的监听器
                .removalListener((key, value, removalCause) -> log.info("remove cache:{}-{}, cause:{}", key, value, removalCause));
        if (loadTypeEnum == LoadTypeEnum.REFRESH) {
            // 配置写入后多久调用load方法刷新缓存
            caffeine.refreshAfterWrite(5, TimeUnit.SECONDS);
        } else {
            // 配置写入后多久使缓存过期
            caffeine.expireAfterWrite(5, TimeUnit.SECONDS);
        }
        if (loadTypeEnum == LoadTypeEnum.ASYNC) {
            // 异步加载
            return caffeine.buildAsync(key -> {
                String value = "value_" + CacheUtil.randomInt();
                log.info(Thread.currentThread().getName() + " load value:{}, cost 3s", value);
                Thread.sleep(3000);
                return value;
            });
        } else if (loadTypeEnum != LoadTypeEnum.MANUAL) {
            // 同步加载
            return caffeine.build(key -> {
                String value = "value_" + CacheUtil.randomInt();
                log.info(Thread.currentThread().getName() + " load value:{}, cost 3s", value);
                Thread.sleep(3000);
                return value;
            });
        } else {
            // 手动加载
            return caffeine.build();
        }
    }
}

1.2 手动加载测试

@Slf4j
public class ManualCacheTest {

    private Cache<String, Object> cache = (Cache<String, Object>) CacheUtil.buildLoadCache(LoadTypeEnum.MANUAL);

    @Test
    public void test() throws InterruptedException {
        String key = "key1";
        cache.put(key, "v1");
        log.info("exist key:" + key + "--->" + cache.getIfPresent(key));
        log.info("not exist key:key2" + "--->" + cache.getIfPresent("key2"));
        // 覆盖key
        cache.put(key, "v2");
        log.info("override key:" + key + "--->" + cache.getIfPresent(key));
        // 作废key
        cache.invalidate(key);
        log.info("invalid key:" + key + "--->" + cache.getIfPresent(key));
        // 过期失效
        cache.put(key, "v1");
        log.info("exist key:" + key + "--->" + cache.getIfPresent(key));
        Thread.sleep(6000);
        log.info("expired key:" + key + "--->" + cache.getIfPresent(key));
    }
}

输出

16:28:37.193 [main] INFO com.cache.demo.ManualCacheTest - exist key:key1--->v1
16:28:37.197 [main] INFO com.cache.demo.ManualCacheTest - not exist key:key2--->null
16:28:37.201 [main] INFO com.cache.demo.ManualCacheTest - override key:key1--->v2
16:28:37.201 [ForkJoinPool.commonPool-worker-1] INFO com.cache.CacheUtil - remove cache:key1-v1, cause:REPLACED
16:28:37.203 [main] INFO com.cache.demo.ManualCacheTest - invalid key:key1--->null
16:28:37.203 [ForkJoinPool.commonPool-worker-1] INFO com.cache.CacheUtil - remove cache:key1-v2, cause:EXPLICIT
16:28:37.204 [main] INFO com.cache.demo.ManualCacheTest - exist key:key1--->v1
16:28:43.206 [main] INFO com.cache.demo.ManualCacheTest - expired key:key1--->null

1.3 同步加载测试

@Slf4j
public class SyncLoadTest {

    LoadingCache<String, Object> loadingCache = (LoadingCache<String, Object>) CacheUtil.buildLoadCache(LoadTypeEnum.SYNC);

    @Test
    public void test() throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            CacheUtil.execute(() -> {
                while (true) {
                    try {
                        log.info(Thread.currentThread().getName() + " " + loadingCache.get("123456"));
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        TimeUnit.HOURS.sleep(2);
    }
}

输出

16:31:04.328 [pool-1-thread-1] INFO com.cache.CacheUtil - pool-1-thread-1 load value:value_647, cost 3s
16:31:07.342 [pool-1-thread-1] INFO com.cache.demo.SyncLoadTest - pool-1-thread-1 value_647
16:31:07.344 [pool-1-thread-2] INFO com.cache.demo.SyncLoadTest - pool-1-thread-2 value_647
16:31:08.344 [pool-1-thread-1] INFO com.cache.demo.SyncLoadTest - pool-1-thread-1 value_647
16:31:08.344 [pool-1-thread-2] INFO com.cache.demo.SyncLoadTest - pool-1-thread-2 value_647
16:31:09.347 [pool-1-thread-1] INFO com.cache.demo.SyncLoadTest - pool-1-thread-1 value_647
16:31:09.347 [pool-1-thread-2] INFO com.cache.demo.SyncLoadTest - pool-1-thread-2 value_647
16:31:10.348 [pool-1-thread-1] INFO com.cache.demo.SyncLoadTest - pool-1-thread-1 value_647
16:31:10.348 [pool-1-thread-2] INFO com.cache.demo.SyncLoadTest - pool-1-thread-2 value_647
16:31:11.353 [pool-1-thread-1] INFO com.cache.demo.SyncLoadTest - pool-1-thread-1 value_647
16:31:11.353 [pool-1-thread-2] INFO com.cache.demo.SyncLoadTest - pool-1-thread-2 value_647
16:31:12.359 [pool-1-thread-1] INFO com.cache.CacheUtil - pool-1-thread-1 load value:value_822, cost 3s
16:31:15.361 [pool-1-thread-2] INFO com.cache.demo.SyncLoadTest - pool-1-thread-2 value_822
16:31:15.363 [ForkJoinPool.commonPool-worker-1] INFO com.cache.CacheUtil - remove cache:123456-value_647, cause:EXPIRED
16:31:15.363 [pool-1-thread-1] INFO com.cache.demo.SyncLoadTest - pool-1-thread-1 value_822

可以看到缓存过期后其中一个读线程阻塞去加载数据，别的线程都阻塞等待

1.4 异步加载测试

@Slf4j
public class AsyncCacheTest {

    AsyncLoadingCache<String, Object> loadingCache = (AsyncLoadingCache<String, Object>) CacheUtil.buildLoadCache(LoadTypeEnum.ASYNC);

    @Test
    public void test() {
        while (true) {
            try {
                CompletableFuture<Object> future = loadingCache.get("123456");
                Thread.sleep(1000);
                log.info("执行别的业务，耗时1s");
                log.info("读取缓存：" + future.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

输出

16:38:22.751 [main] INFO com.cache.demo.AsyncCacheTest - 执行别的业务，耗时1s
16:38:22.751 [main] INFO com.cache.demo.AsyncCacheTest - 读取缓存：value_922
16:38:23.755 [main] INFO com.cache.demo.AsyncCacheTest - 执行别的业务，耗时1s
16:38:23.756 [main] INFO com.cache.demo.AsyncCacheTest - 读取缓存：value_922
16:38:23.758 [ForkJoinPool.commonPool-worker-2] INFO com.cache.CacheUtil - ForkJoinPool.commonPool-worker-2 load value:value_457, cost 3s
16:38:23.759 [ForkJoinPool.commonPool-worker-1] INFO com.cache.CacheUtil - remove cache:123456-value_922, cause:EXPIRED
16:38:24.763 [main] INFO com.cache.demo.AsyncCacheTest - 执行别的业务，耗时1s
16:38:26.763 [main] INFO com.cache.demo.AsyncCacheTest - 读取缓存：value_457
16:38:27.764 [main] INFO com.cache.demo.AsyncCacheTest - 执行别的业务，耗时1s

可以看到异步加载利用future模式实现加载缓存的同时不影响别的业务

1.5 自动刷新缓存

public class RefreshLoadTest {

    LoadingCache<String, Object> loadingCache = (LoadingCache<String, Object>) CacheUtil.buildLoadCache(LoadTypeEnum.REFRESH);

    @Test
    public void test() throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            CacheUtil.execute(() -> {
                while (true) {
                    try {
                        log.info(Thread.currentThread().getName() + " " + loadingCache.get("123456"));
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        TimeUnit.HOURS.sleep(2);
    }
}

输出

16:41:20.254 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_704
16:41:21.254 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_704
16:41:21.255 [pool-1-thread-1] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-1 value_704
16:41:22.258 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_704
16:41:22.261 [ForkJoinPool.commonPool-worker-1] INFO com.cache.CacheUtil - ForkJoinPool.commonPool-worker-1 load value:value_138, cost 3s
16:41:22.265 [pool-1-thread-1] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-1 value_704
16:41:23.263 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_704
16:41:23.269 [pool-1-thread-1] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-1 value_704
16:41:24.267 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_704
16:41:24.270 [pool-1-thread-1] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-1 value_704
16:41:25.269 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_704
16:41:25.272 [pool-1-thread-1] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-1 value_704
16:41:25.277 [ForkJoinPool.commonPool-worker-2] INFO com.cache.CacheUtil - remove cache:123456-value_704, cause:REPLACED
16:41:26.270 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_138
16:41:26.274 [pool-1-thread-1] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-1 value_138
16:41:27.274 [pool-1-thread-2] INFO com.cache.demo.RefreshLoadTest - pool-1-thread-2 value_138

可以看到缓存过期后读线程都返回老数据，单开一个线程加载数据

1.6 统计命中率

public class CacheStatTest {

    LoadingCache<String, Object> loadingCache = (LoadingCache<String, Object>) CacheUtil.buildLoadCache(LoadTypeEnum.REFRESH);

    @Test
    public void test() throws InterruptedException {
        for (int j = 0; j < 5; j++) {
            for (int i = 0; i < 10; i++) {
                loadingCache.get(i + "");
            }
        }
        loadingCache.get("11");
        CacheStats stats = loadingCache.stats();
        log.info("hit count:{}, missCount:{}, hit rate:{}",
                stats.hitCount(), stats.missCount(), stats.hitRate());
        TimeUnit.HOURS.sleep(1);
    }
}

测试前先注释掉工具类中的睡眠代码

输出：16:51:45.128 [main] INFO com.cache.demo.CacheStatTest - hit count:40, missCount:11, hit rate:0.7843137254901961

2 源码浅析

开发中常用1.5 自动刷新缓存，就看看LoadingCache.get()中做了什么

追到com.github.benmanes.caffeine.cache.BoundedLocalCache#computeIfAbsent

2.1 computeIfAbsent方法概览

  public @Nullable V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction,
      boolean recordStats, boolean recordLoad) {
    requireNonNull(key);
    // mappingFunction就是用cacheLoader构建的
    requireNonNull(mappingFunction);
    long now = expirationTicker().read();

    // data是ConcurrentHashMap
    Node<K, V> node = data.get(nodeFactory.newLookupKey(key));
    if (node != null) {
      V value = node.getValue();
      if ((value != null) && !hasExpired(node, now)) {
        if (!isComputingAsync(node)) {
          // 如果采用expireAfterRead过期策略则修改过期时间
          tryExpireAfterRead(node, key, value, expiry(), now);
          // 修改缓存访问时间
          setAccessTime(node, now);
        }
        // 读缓存后的操作
        afterRead(node, now, /* recordHit */ recordStats);
        return value;
      }
    }
    if (recordStats) {
      // 统计信息，没有命中次数增加
      mappingFunction = statsAware(mappingFunction, recordLoad);
    }
    // 根据引用类型重新构建key
    Object keyRef = nodeFactory.newReferenceKey(key, keyReferenceQueue());
    // 2.2 计算缓存value
    return doComputeIfAbsent(key, keyRef, mappingFunction, new long[] { now }, recordStats);
  }

computeIfAbsent方法主要做了如下操作

1 根据key取node

2 如果node不为空且没过期则做一些额外操作，然后返回value

3 如果node为空则先统计命中信息，然后加载缓存

2.2 doComputeIfAbsent方法分析

 @Nullable V doComputeIfAbsent(K key, Object keyRef,
      Function<? super K, ? extends V> mappingFunction, long[/* 1 */] now, boolean recordStats) {
    // 旧值引用
    V[] oldValue = (V[]) new Object[1];
    // 新值引用
    V[] newValue = (V[]) new Object[1];
    // key引用
    K[] nodeKey = (K[]) new Object[1];
    // 移除的node引用
    Node<K, V>[] removed = new Node[1];

    int[] weight = new int[2]; // old, new
    RemovalCause[] cause = new RemovalCause[1];
    Node<K, V> node = data.compute(keyRef, (k, n) -> {
      if (n == null) {
        // 根据key获取新的value
        newValue[0] = mappingFunction.apply(key);
        if (newValue[0] == null) {
          return null;
        }
        now[0] = expirationTicker().read();
        weight[1] = weigher.weigh(key, newValue[0]);
        // 构建value node
        n = nodeFactory.newNode(key, keyReferenceQueue(),
            newValue[0], valueReferenceQueue(), weight[1], now[0]);
        setVariableTime(n, expireAfterCreate(key, newValue[0], expiry(), now[0]));
        return n;
      }
      // 如果旧值不为空则进行如下处理
      synchronized (n) {
        // 根据老的k-v设置移除原因
        nodeKey[0] = n.getKey();
        weight[0] = n.getWeight();
        oldValue[0] = n.getValue();
        if ((nodeKey[0] == null) || (oldValue[0] == null)) {
          cause[0] = RemovalCause.COLLECTED;
        } else if (hasExpired(n, now[0])) {
          cause[0] = RemovalCause.EXPIRED;
        } else {
          return n;
        }

        writer.delete(nodeKey[0], oldValue[0], cause[0]);
        // 计算新值
        newValue[0] = mappingFunction.apply(key);
        if (newValue[0] == null) {
          removed[0] = n;
          // 旧值清理
          n.retire();
          return null;
        }
        weight[1] = weigher.weigh(key, newValue[0]);
        // 旧node设置新值
        n.setValue(newValue[0], valueReferenceQueue());
        n.setWeight(weight[1]);

        now[0] = expirationTicker().read();
        // 设置读写时间
        setVariableTime(n, expireAfterCreate(key, newValue[0], expiry(), now[0]));
        setAccessTime(n, now[0]);
        setWriteTime(n, now[0]);
        return n;
      }
    });

    if (node == null) {
      if (removed[0] != null) {
        // 添加一个旧node移除任务
        afterWrite(new RemovalTask(removed[0]));
      }
      return null;
    }
    if (cause[0] != null) {
      if (hasRemovalListener()) {
        // 如果旧值移除原因不为空并且配置了移除监听则进行通知
        notifyRemoval(nodeKey[0], oldValue[0], cause[0]);
      }
      statsCounter().recordEviction(weight[0], cause[0]);
    }
    if (newValue[0] == null) {
      if (!isComputingAsync(node)) {
        // 如果设置了expireAfterRead则延长过期时间
        tryExpireAfterRead(node, key, oldValue[0], expiry(), now[0]);
        // 设置访问时间
        setAccessTime(node, now[0]);
      }
      // node读取后的操作
      afterRead(node, now[0], /* recordHit */ recordStats);
      // 返回旧值
      return oldValue[0];
    }
    if ((oldValue[0] == null) && (cause[0] == null)) {
      // 添加一个添加node的任务
      afterWrite(new AddTask(node, weight[1]));
    } else {
      int weightedDifference = (weight[1] - weight[0]);
      // 添加一个修改node的任务
      afterWrite(new UpdateTask(node, weightedDifference));
    }

    return newValue[0];
  }

doComputeIfAbsent主要做了如下操作

1 计算新值

2 旧值移除相关操作(添加移除任务，旧值移除监听处理)

3 新值添加相关操作(添加添加node、修改node任务)

孟诸
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
高性能本地缓存组件 Caffeine Cache
公众号：微观技术
04-02 793
Spring Boot 作为主流微服务框架，拥有成熟的社区生态。市场应用广泛，为了方便大家，整理了一个基于spring boot的常用中间件快速集成入门系列手册，涉及RPC、缓存、消息队列、分库分表、注册中心、分布式配置等常用开源组件，大概有几十篇文章，陆续会开放出来，感兴趣同学请提前关注&收藏 Redis 作为分布式缓存组件提供多个服务间的缓存，但是 Redis 需要网络开销，增加耗时。本地缓存是直接从本地内存中读取数据，没有网络开销，性能更高，例如秒杀系统或者数据量小的缓存等，比远程缓存更.
spring-boot-redis-guava-caffeine-cache:springboot 使用 redis guava caffeine 缓存示例
05-17
本项目"spring-boot-redis-guava-caffeine-cache"主要探讨了如何在Spring Boot应用中集成Redis、Guava和Caffeine三种不同的缓存策略。 首先，Redis是一款开源的内存数据结构存储系统，常被用作数据库、缓存和消息...
实战-商品中心-l2cache中caffeine.getIfPresent()仅仅获取缓存，但触发了数据加载，导致被设置为NullValue的问题分析
白云
06-02 3843
实战-l2cache中caffeine.getIfPresent()仅仅获取缓存，但触发了数据加载，导致被设置为NullValue的问题分析
Caffeine缓存指南
最新发布
漫天飞雪
06-15 784
Caffeine是一个由Ben Manes开发的高性能缓存库，灵感来源于Guava Cache，并在其基础上进行了大量的性能优化。Caffeine提供了一种近乎最优的缓存解决方案，具有低延迟、高吞吐量、灵活配置等特点。支持多种缓存策略，如LRU、LFU等提供细粒度的过期控制和自动刷新机制内置统计监控功能，便于性能调优易于集成，提供简单直观的API缓存是一种常见的性能优化技术，通过在内存中存储经常访问的数据，减少对数据库或其他外部数据源的访问，从而提高系统的响应速度。缓存策略。
咖啡因Caffeine
qq_35653822的博客
11-01 875
1.本地缓存使用 2.最让我惊艳的是getAll方法 起初是为了存list，人员信息每次查询时候，都会传一组不同的list给我，我为了不每次都调用rpc接口，就想到用一个map<Long,Employee> 但是又要自行去过滤哪些不是map中已经存在的，而且不止我这要用到这个，所以我还得写个自定义注解@Aroung，就感觉有点麻烦 3.getAll方法它其实包括了put和get还有过滤这三个操作 3.1先上代码再bb public static final Cache<
Caffeine教程
做的过程自我总结
02-09 1718
如果是想直接看官网教程的请移步：https://github.com/ben-manes/... 而如果还想结合实际应用场景，以及各种坑的，请看本文。 最近来了一个实习生小张，看了我在公司项目中使用的缓存框架Caffeine，三天两头跑来找我取经，说是要把Caffeine吃透，为此无奈的也只能一个个细心解答了。 后来这件事情被总监直到了，说是后面还有新人，让我将相关问题和细节汇总成一份教程，权当共享好了，该份教程也算是全网第一份，结合了目前我司游戏中业务场景的应用和思考，以及踩过的坑。 实习生小张：
tcp压力测试工具_【技术】TCP 的固定窗口和滑动窗口
weixin_39782355的博客
12-10 264
关注我，你的眼睛会怀孕固定窗口●TCP 还提供了流量控制机制。流量控制可以调整给定会话中源和目的之间的 数据流速，有助于保持 TCP 传输的可靠性。流量控制的实施方法包括限制 一次可以转发的数据段数量，并要求在发送更多数据段之前确认接收。● 要实施流量控制，TCP 要确定的第一件事是目的设备可以接受的数据段数量。TCP 报头包括一个称为“窗口大小”的 16 位字段。这是 TCP ...
Caffeine本地缓存
04-27
Caffeine是一个高性能的本地缓存库，专为Java 8设计，被广泛应用于需要快速访问数据的场景，尤其在Spring 5之后成为了默认的缓存实现，替代了原本的Guava缓存。本地缓存的优势在于它可以避免网络通信带来的延迟，...
java编程之Caffeine缓存
12-16
Caffeine是本地缓存，也就是和本机内存交互，读取和存入缓存在本机内存 缓存包括本地缓存和分部署缓存，对于本地缓存而言，不需要考虑集群问题，因为本地缓存就是指服务器的缓存。 ### 注解 @Cacheable：...
本地缓存之王Caffeine 保姆级教程（值得珍藏）
01-27
Caffeine不仅提供了高性能的缓存操作，还具有自适应的内存管理和灵活的过期策略。 Caffeine的核心特性体现在以下几个方面： 1. **高性能**：Caffeine通过采用先进的数据结构（如链表和哈希表）和优化算法（如并发...
cache-spring-boot-starter:基于spring cloud bus + rabbitmq + caffeine, 可以自动更新集群内所有同服务实例的内存缓存
04-13
cache-spring-boot-starter介绍基于spring cloud bus + rabbitmq + caffeine, 可以自动更新集群内同服务所有实例的内存缓存使用说明1. 添加依赖<dependency> <groupId>...
缓存之王Caffeine Cache，性能比Guava更强，命中率更高
Java搜索工程技术栈
06-20 860
在项目开发中，为提升系统性能，减少 IO 开销，本地缓存是必不可少的。最常见的本地缓存是 Guava 和 Caffeine，本篇文章将为大家介绍 Caffeine。Caffeine 是基于 Google Guava Cache 设计经验改进的结果，相较于 Guava 在性能和命中率上更具有效率，你可以认为其是 Guava Plus。毋庸置疑的，你应该尽快将你的本地缓存从 Guava 迁移至 Caffeine，本文将重点和 Guava 对比二者性能占据，给出本地缓存的最佳实践，以及迁移策略。从功能上看，Gua
Java 缓存——Caffeine
JimmyYang的博客
07-31 393
Caffeine 手动模式 public static void main(String[] args) { String key = "test"; // 创建 手动模式的缓存 Cache<String, String> cache = Caffeine.newBuilder() .expireAfterWrite(10, TimeUnit.MINUTES) .maximum
Caffeine - Caches - Population
ttyy1112的专栏
11-05 155
填充策略 Caffeine提供了4中填充策略：手动加载、同步加载以及异步变体（异步手工、异步加载）。 手动加载 Cache<Key, Graph> cache = Caffeine.newBuilder() .expireAfterWrite(10, TimeUnit.MINUTES) .maximumSize(10_000) .build(); // Loo...
Java本地缓存之Caffeine的使用
我不是攻城狮的博客
10-25 4620
java本地缓存只Caffeine的使用以及缓存的理解
caffeine 读操作源码走读 为什么读这么快
不说话装高手
05-30 1035
Caffeine通过get()方法获取缓存中的数据。 Node<K, V> node = data.get(nodeFactory.newLookupKey(key)); if (node == null) { if (recordStats) { statsCounter().recordMisses(1); } return null; } long now = expirationTicker().read(); if (hasExpired(node, now))
使用Caffeine库的Java本地缓存详解
cxkjntm123的博客
12-25 1513
在Java编程语言中，Caffeine是一个开源的缓存库，用于提供高性能的本地缓存实现。它支持在应用程序中轻松管理缓存，并提供了许多灵活的配置选项。
Caffeine入门使用
热门推荐
l_dongyang的博客
09-08 1万+
目录一、概况简介：优点：二、使用坐标缓存填充策略过期策略时间监听外部存储springboot集成三、参考文档功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、概况 就一般的互联网行业中的应用而言，目前比较通用的并且也是普遍存在的
Caffeine缓存
qq_35448165的博客
11-08 8278
在本文中，我们来看看 Caffeine — 一个高性能的 Java 缓存库。 缓存和 Map 之间的一个根本区别在于缓存可以回收存储的 item。 回收策略为在指定时间删除哪些对象。此策略直接影响缓存的命中率 — 缓存库的一个重要特征。 Caffeine 因使用 Window TinyLfu 回收策略，提供了一个近乎最佳的命中率。 填充策略（Population） Caffeine 为我们提供了三种填充策略：手动、同步和异步 手动加载（Manual） Cache<String, Object>
缓存工具Caffeine 的api介绍
05-13
Caffeine是一种Java缓存库，其API包含以下主要接口： 1. Cache：表示一个通用缓存存储。该接口提供了读取、写入和删除缓存条目的方法。 2. LoadingCache：是Cache接口的子接口，它可以自动加载缓存中不存在的条目...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值