guava cache 的refreshAfterWrite模式存在无效key的问题记录

已于 2023-03-24 10:52:29 修改
阅读量2.4k 收藏 2
点赞数 1
分类专栏： JAVA guava 文章标签： guava失效key
于 2020-08-27 17:14:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yichen0429/article/details/108257724
版权
JAVA 同时被 2 个专栏收录
20 篇文章 0 订阅
订阅专栏
guava
1 篇文章 0 订阅
订阅专栏

问题暴露

某个缓存key和对应的value被缓存到guava后，一段时间后该key对应的记录在数据库中被删除；
当这个key再次被获取的时候，到达refreshAfterWrite设置时间触发refresh方法， 然后委托给我们自己实现的reload方法，我们的reload方法又调用了load方法来重新刷新该key对应的最新值。那么这个时候问题来了。因为我们知道，如果一个key曾经没有存在过，触发load方法的时候，我们return null,最终guava不会去增加一个key来保存这一对无效键值对。
但是现在我们的问题是这个key是存在的，只是现在刷新的时候发现值不存在了，变成了null。程序如果不管这种情况的话，由于guava不接收value为null的缓存，然后内部会抛出异常，最终那本该不存在的旧值就又会一直占用这个key的缓存。然后获取缓存的线程又会只会判断是否为null，然后执行业务，最终就会拿着被删除的垃圾数据走业务，而且这个垃圾数据会一直存在。

问题演示

下面会简单写一个demo,然后用来演示上面那个问题， 步骤描述

  • 有一个对象为Person, 然后使用guava的refreshAfterWrite来进行缓存
  • 某一个Person被缓存后，随后这个对象对应的记录在数据库被删除了
  • 然后发现我们从缓存中获取对应被删除的对象的key即使已经刷新了无数遍发现数据还是会一直存在，而不是null
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListenableFutureTask;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import jdk.reflect.StringUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * <p>description</p >
 *
 * @author Snowball
 * @version 1.0
 * @date 2020/08/27 14:46
 */
@Slf4j
public class Demo {
    /**
     * 原始数据集合,模拟数据库记录
     */
    private final static Map<String, Person> DATA_MAP;

    /**
     * guava缓存Person
     */
    private static LoadingCache<String, Person> INIT_LOADING_CACHE;

    /**
     * reload线程池
     */
    private final static ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(500), new ThreadFactoryBuilder().setNameFormat("reload-executor-pool").build());

    static {
        // 初始化原始数据,模拟数据库中的记录
        DATA_MAP = new HashMap<>();
        DATA_MAP.put("1", new Person("1", "jack"));
        DATA_MAP.put("2", new Person("2", "tom"));

        // 初始化缓存
        initLazyCache();
    }

    /**
     * 初始化缓存
     */
    private static void initLazyCache() {
        INIT_LOADING_CACHE = CacheBuilder.newBuilder()
                .maximumSize(500)
                .recordStats()
                .softValues()
                .refreshAfterWrite(3, TimeUnit.SECONDS)
                .build(new CacheLoader<String, Person>() {
                    @Override
                    public Person load(String key) throws Exception {
                        System.out.println("=================load===================: " + key);
                        if (StringUtil.isBlank(key)) {
                            return null;
                        }
                        String[] data= key.split(CacheKeyEnum.SPLIT_CHAR);
                        // LoadingCacheDemo1:INIT:{0}
                        String id = data[2];
                        return get(id);
                    }

                    @Override
                    public ListenableFuture<Person> reload(String key, Person oldValue) throws Exception {
                        // 如果使用异步的话，短期内多次获取，因为此时异步尚未执行结束，大概率会造成获取的时候使用的还是旧的缓存值
                        ListenableFutureTask<Person> task = ListenableFutureTask.create(() -> load(key));
                        EXECUTOR.execute(task);
                        // 可选是否采用闭锁再刷新的时候让读线程等待刷新完成，一般不需要，就异步刷新即可
                        task.get();
                        return task;
                    }
                });
        // 这里也可以直接初始化缓存，就不用懒加载获取某个key的时候再去缓存
        DATA_MAP.forEach((k, v) -> {
            INIT_LOADING_CACHE.put(MessageFormat.format(CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), k), v);
        });
    }
    public static void main(String[] args) throws InterruptedException {
        System.out.println("==============================================initLoad===========================================");

        String id = "2";
        System.out.println("由于缓存进行了启动初始化加载，所以第一次如果key存在，会直接拿缓存");
        logTimeGet(INIT_LOADING_CACHE, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);

        DATA_MAP.put(id, new Person(id, DATA_MAP.get(id).getUsername() + "被修改了"));
        System.out.println("id=2的对象，由于没有到刷新时间, 所以用的还是旧值");
        logTimeGet(INIT_LOADING_CACHE, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);

        Thread.sleep(3000);
        System.out.println("故意睡眠超过过期时间，过期之后的第一次请求触发刷新操作，由于我们使用了闭锁，让获取值的线程强制等待刷新任务完整，所以这里会耗时比较久，但值是最新的");
        logTimeGet(INIT_LOADING_CACHE, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);

        // 下面就要演示如果这个key被删除了，其实最终guava不接受为null的value,会导致这个无效key一直存在，且对应的value为最后一次缓存的数据
        DATA_MAP.remove(id);
        // 故意超过过期时间，保证会触发reload
        Thread.sleep(3000);
        System.out.println("模拟数据库删除key=2的数据");
        // 我们已经使用了闭锁来保证刷新时的同步获取来保证演示效果， 这里guava会抛出异常CacheLoader returned null for key LoadingCacheDemo1:INIT:2.
        // 因为它不接受为null的value, 最终这个缓存会无法置空, 然后就悲剧了，这个key的value我们以为是null，实际一直是最后一次缓存的数据
        logTimeGet(INIT_LOADING_CACHE, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);
        System.out.println("打印一下缓存中的数据，需要说明的是，这里不是由于缓存未刷新造成的数据不一致，而是由于刷新时对应key的记录变成了null而guava不接受所造成的");
        System.out.println(INIT_LOADING_CACHE.asMap());

        EXECUTOR.shutdown();
    }

    /**
     * 模拟获取原始数据
     * @param key
     * @return
     */
    public static Person get(String key) {
        try {
            // 模拟向数据库中取数据需要耗时1000毫秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return DATA_MAP.get(key);
    }

    private static <T> void logTimeGet(LoadingCache<String, T> loadingCache, String template, String... parameter) {
        long before = System.currentTimeMillis();
        System.out.println("缓存中[" + MessageFormat.format(template, parameter) + "]对应的值: "
                + LocalCacheUtil.getGuavaCache(loadingCache, template, parameter));
        long after = System.currentTimeMillis();
        System.out.println("耗时: " + (after - before));
        System.out.println("--------------------------------------");
    }


    /**
     * 获取对应缓存中的值
     * @param loadingCache
     * @param template
     * @param parameter
     * @param <T>
     * @return
     */
    public static <T> T getGuavaCache(LoadingCache<String, T> loadingCache, String template, String... parameter) {
        try {
            return loadingCache.get(MessageFormat.format(template, parameter));
        } catch (CacheLoader.InvalidCacheLoadException e) {
            return null;
        } catch (Exception e) {
            log.error("查询缓存异常 template={},parameter={}", template, parameter);
            return null;
        }
    }

    /**
     * 缓存key维护
     */
    public enum CacheKeyEnum {
        /**
         * 演示初始化加载的缓存
         * {0} id
         */
        LOADING_CACHE_DEMO1_INIT("LoadingCacheDemo1:INIT:{0}"),

        ;

        public static final String SPLIT_CHAR = ":";

        CacheKeyEnum(String template) {
            this.template = template;
        }

        private final String template;

        public String getTemplate() {
            return template;
        }
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Person {

        private String id;

        private String username;
    }

}

打印结果如下:

==============================================initLoad===========================================
由于缓存进行了启动初始化加载，所以第一次如果key存在，会直接拿缓存
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom)
耗时: 1
--------------------------------------
id=2的对象，由于没有到刷新时间, 所以用的还是旧值
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom)
耗时: 0
--------------------------------------
故意睡眠超过过期时间，过期之后的第一次请求触发刷新操作，由于我们使用了闭锁，让获取值的线程强制等待刷新任务完整，所以这里会耗时比较久，但值是最新的
=================load===================: LoadingCacheDemo1:INIT:2
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom被修改了)
耗时: 1038
--------------------------------------
模拟数据库删除key=2的数据
=================load===================: LoadingCacheDemo1:INIT:2
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom被修改了)
耗时: 1016
--------------------------------------
打印一下缓存中的数据，需要说明的是，这里不是由于缓存未刷新造成的数据不一致，而是由于刷新时对应key的记录变成了null造成的
{LoadingCacheDemo1:INIT:1=Demo.Person(id=1, username=jack), LoadingCacheDemo1:INIT:2=Demo.Person(id=2, username=tom被修改了)}

解决思路

  1. 首先明白问题是出现在这个key曾经存在过，然后被删除之后重新从数据库查询发现为null之后，然后我们直接将null交给guava，本以为会让这个value为null，然后业务判断不为null即可，但是最终guava不受理一个存在的key被重置为null, 才会引起这个问题
  2. 那么就只能从默认值下手了。给每个要缓存的对象一个代表无效的空对象，如果为集合则为空集合，然后在load方法内部通过key去获取最新值的时候需要判断这个值是否为null， 如果为null并且这个key在缓存中存在，则返回我们预定义的空对象。记住一定要加上这个key之前在缓存中存在才做默认值的处理。因为如果key不存在我们返回null, guava根本不会去缓存这个key。如果不加这个判断，我们就让guava多缓存了一堆无效数据了。
  3. 在通过guava获取值的地方，除了要判断值不为null之外，还要判断这个值是不是我们之前存入的代表无效value的对象。如果是的话，这个数据不可使用，不能走业务代码。同时调用LoadingCache的invalidate方法来将key失效掉

步骤2对应调整

  • 增加要缓存对象的默认无效值
    public static final Person INVALID_PERSON = new Person();
  • 调整guava缓存定义时的load方法，调整部分如下
    Person person = get(id);
// 如果值为null且这个key之前存在过， 要放入默认值；如果值为null但这个key不存在，guava本就不会缓存这个key
if (person == null && INIT_LOADING_CACHE.asMap().containsKey(key)) {
    System.out.printf("【%s】对应的记录被删除，存入默认值\r\n", key);
    person = Person.INVALID_PERSON;
}
return person;

步骤3调整
介于步骤3，实在是对在使用的地方有侵入，我们可以更改一下前面写的获取缓存的工具方法，除了允许调用方传入要从哪个缓存中取数据，以及对应的key之外，我们再增加默认对象参数，然后我们再工具方法中去完成步骤3的动作，然后发现获取的值为传入的默认对象后，调用invalidate方法并且返回null给调用方，这样就可以让获取缓存的地方无感这一切，依然只判断null即可

public static <T> T getGuavaCacheCheckDefault(LoadingCache<String, T> loadingCache, T defaultValidValue, String template, String... parameter) {
    try {
        String key = MessageFormat.format(template, parameter);
        T t = loadingCache.get(key);
        if (defaultValidValue instanceof String) {
            if (Objects.equals(t, defaultValidValue)) {
                log.info("key: {}对应的值为无效值: {}, 转换为null返回并清除该key", key, t);
                loadingCache.invalidate(key);
                return null;
            }
        } else {
            if (t == defaultValidValue) {
                log.info("key: {}对应的值为无效值: {}, 转换为null返回并清除该key", key, t);
                loadingCache.invalidate(key);
                return null;
            }
        }
        return t;
    } catch (CacheLoader.InvalidCacheLoadException e) {
        return null;
    } catch (Exception e) {
        log.error("查询缓存异常 template={},parameter={}", template, parameter);
        return null;
    }
}

最终完成代码和演示效果

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListenableFutureTask;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import jdk.reflect.StringUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * <p>description</p >
 *
 * @author Snowball
 * @version 1.0
 * @date 2020/08/27 14:46
 */
@Slf4j
public class Demo {
    /**
     * 原始数据集合,模拟数据库记录
     */
    private final static Map<String, Person> DATA_MAP;

    /**
     * 初始化直接缓存全部资
     */
    private static LoadingCache<String, Person> INIT_LOADING_CACHE;

    /**
     * reload线程池
     */
    private final static ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(500), new ThreadFactoryBuilder().setNameFormat("reload-executor-pool").build());

    static {
        // 初始化原始数据
        DATA_MAP = new HashMap<>();
        DATA_MAP.put("1", new Person("1", "jack"));
        DATA_MAP.put("2", new Person("2", "tom"));

        // 初始化缓存
        initLazyCache();
    }

    /**
     * 初始化缓存
     */
    private static void initLazyCache() {
        INIT_LOADING_CACHE = CacheBuilder.newBuilder()
                .maximumSize(500)
                .recordStats()
                .softValues()
                .refreshAfterWrite(3, TimeUnit.SECONDS)
                .build(new CacheLoader<String, Person>() {
                    @Override
                    public Person load(String key) throws Exception {
                        System.out.println("=================load===================: " + key);
                        if (StringUtil.isBlank(key)) {
                            return null;
                        }
                        String[] data= key.split(CacheKeyEnum.SPLIT_CHAR);
                        // LoadingCacheDemo1:INIT:{0}
                        String id = data[2];
                        Person person = get(id);
                        // 如果值为null且这个key之前存在过， 要放入默认值；如果值为null但这个key不存在，guava本就不会缓存这个key，我们没必要增加
                        if (person == null && INIT_LOADING_CACHE.asMap().containsKey(key)) {
                            System.out.printf("【%s】对应的记录被删除，存入默认值\r\n", key);
                            person = Person.INVALID_PERSON;
                        }
                        return person;
                    }

                    @Override
                    public ListenableFuture<Person> reload(String key, Person oldValue) throws Exception {
                        // 如果使用异步的话，短期内多次获取，因为此时异步尚未执行结束，大概率会造成获取的时候使用的还是旧的缓存值
                        ListenableFutureTask<Person> task = ListenableFutureTask.create(() -> load(key));
                        EXECUTOR.execute(task);
                        // 可选是否采用闭锁再刷新的时候让读线程等待刷新完成，一般不需要，就异步刷新即可
                        task.get();
                        return task;
                    }
                });
        // 这里也可以直接初始化缓存，就不用懒加载获取某个key的时候再去缓存
        DATA_MAP.forEach((k, v) -> {
            INIT_LOADING_CACHE.put(MessageFormat.format(CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), k), v);
        });
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("==============================================initLoad===========================================");

        String id = "2";
        System.out.println("由于缓存进行了启动初始化加载，所以第一次如果key存在，会直接拿缓存");
        logTimeGet(INIT_LOADING_CACHE, Person.INVALID_PERSON, guava.cache.CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);

        DATA_MAP.put(id, new Person(id, DATA_MAP.get(id).getUsername() + "被修改了"));
        System.out.println("id=4的对象，由于没有到刷新时间, 所以用的还是旧值");
        logTimeGet(INIT_LOADING_CACHE, Person.INVALID_PERSON, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);

        Thread.sleep(3000);
        System.out.println("故意睡眠超过过期时间，过期之后的第一次请求触发刷新操作，由于我们使用了闭锁，让获取值的线程强制等待刷新任务完整，所以这里会耗时比较久，但值是最新的");
        logTimeGet(INIT_LOADING_CACHE, Person.INVALID_PERSON, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);

        // 下面就要演示如果这个key被删除了，其实最终guava不接受为null的value,会导致这个无效key一直存在，且对应的value为最后一次缓存的数据
        DATA_MAP.remove(id);
        // 故意超过过期时间，保证会触发reload
        Thread.sleep(3000);
        System.out.println("模拟数据库删除key=4的数据");
        // 我们已经使用了闭锁来保证刷新时的同步获取来保证演示效果, 这里写的工具方法内部会判断是否为默认值，然后转换为null返回，并且删除key
        logTimeGet(INIT_LOADING_CACHE, Person.INVALID_PERSON, CacheKeyEnum.LOADING_CACHE_DEMO1_INIT.getTemplate(), id);
        System.out.println("打印一下缓存中的数据，我们发现上面工具完成了返回null的操作方便我们使用的地方判断，而且也完成了对该key的删除");
        System.out.println(INIT_LOADING_CACHE.asMap());

        EXECUTOR.shutdown();
    }

    /**
     * 模拟获取原始数据
     * @param key
     * @return
     */
    public static Person get(String key) {
        try {
            // 模拟向数据库中取数据需要耗时1000毫秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return DATA_MAP.get(key);
    }

    private static <T> void logTimeGet(LoadingCache<String, T> loadingCache, T invalidValue, String template, String... parameter) {
        long before = System.currentTimeMillis();
        System.out.println("缓存中[" + MessageFormat.format(template, parameter) + "]对应的值: "
                + LocalCacheUtil.getGuavaCacheCheckDefault(loadingCache, invalidValue, template, parameter));
        long after = System.currentTimeMillis();
        System.out.println("耗时: " + (after - before));
        System.out.println("--------------------------------------");
    }


    /**
     * 获取对应缓存中的值
     * @param loadingCache
     * @param template
     * @param parameter
     * @param <T>
     * @return
     */
    public static <T> T getGuavaCache(LoadingCache<String, T> loadingCache, String template, String... parameter) {
        try {
            return loadingCache.get(MessageFormat.format(template, parameter));
        } catch (CacheLoader.InvalidCacheLoadException e) {
            return null;
        } catch (Exception e) {
            log.error("查询缓存异常 template={},parameter={}", template, parameter);
            return null;
        }
    }

    /**
     * 缓存key维护
     */
    public enum CacheKeyEnum {
        /**
         * 演示初始化加载的缓存
         * {0} id
         */
        LOADING_CACHE_DEMO1_INIT("LoadingCacheDemo1:INIT:{0}"),

        ;

        public static final String SPLIT_CHAR = ":";

        CacheKeyEnum(String template) {
            this.template = template;
        }

        private final String template;

        public String getTemplate() {
            return template;
        }
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Person {

        /**
         * 代表无效值的Person对象
         */
        public static final Person INVALID_PERSON = new Person();

        private String id;

        private String username;
    }
}

打印效果如下:

==============================================initLoad===========================================
由于缓存进行了启动初始化加载，所以第一次如果key存在，会直接拿缓存
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom)
耗时: 1
--------------------------------------
id=4的对象，由于没有到刷新时间, 所以用的还是旧值
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom)
耗时: 0
--------------------------------------
故意睡眠超过过期时间，过期之后的第一次请求触发刷新操作，由于我们使用了闭锁，让获取值的线程强制等待刷新任务完整，所以这里会耗时比较久，但值是最新的
=================load===================: LoadingCacheDemo1:INIT:2
缓存中[LoadingCacheDemo1:INIT:2]对应的值: Demo.Person(id=2, username=tom被修改了)
耗时: 1033
--------------------------------------
模拟数据库删除key=4的数据
=================load===================: LoadingCacheDemo1:INIT:2
【LoadingCacheDemo1:INIT:2】对应的记录被删除，存入默认值
16:58:23.510 [main] INFO  guava.cache.LocalCacheUtil - key: LoadingCacheDemo1:INIT:2对应的值为无效值: Demo.Person(id=null, username=null), 转换为null返回并清除该key
缓存中[LoadingCacheDemo1:INIT:2]对应的值: null
耗时: 1019
--------------------------------------
打印一下缓存中的数据，我们发现上面工具完成了返回null的操作方便我们使用的地方判断，而且也完成了对该key的删除
{LoadingCacheDemo1:INIT:1=Demo.Person(id=1, username=jack)}
DDF_YiChen
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Guava】Guava Cache的refresh和expire刷新机制
九师兄
09-27 3414
1.概述 转载：https://www.cnblogs.com/liuxiaochong/p/13613071.html 总览参考：【Guava】Google Guava本地高效缓存 2.思考和猜想 首先看一下三种基于时间的清理或刷新缓存数据的方式： expireAfterAccess： 当缓存项在指定的时间段内没有被读或写就会被回收。 expireAfterWrite：当缓存项在指定的时间段内没有更新就会被回收。 refreshAfterWrite：当缓存项上一次更新操作之后的多久会被刷新。 考虑到时
Guava Cache特性：refreshAfterWrite只阻塞回源线程，其他线程返回旧值
热门推荐
aty
12-07 2万+
真正加载数据的那个线程一定会阻塞，我们希望这个加载过程是异步的。这样就可以让所有线程立马返回旧值，在后台刷新缓存数据。refreshAfterWrite默认的刷新是同步的，会在调用者的线程中执行。我们可以改造成异步的，实现CacheLoader.reload()。
深入Guava Cache的refresh和expire刷新机制
try to do
05-08 353
Guava Cache是本地缓存的不二之选，用起来真不错呵，可是你真的知道怎么使用才能满足需求？今天我们深入探讨一下Expire和Refresh。（废话少说）
GuavaCache的refreshAfterWrite
tangxz的博客
03-13 8156
expireAfterAccess：一段时间内没有访问则过期，如果有多个线程同时查询，则阻塞所有线程，一个线程去获取数据。refreshAfterWrite：可以不重写reload。如果缓存过期，则一个线程去获取数据，其他线程返回老数据。expireAfterWrite：如果缓存过期，则阻塞所有线程，一个线程去获取数据。
Guava Cache特性：refreshAfterWrite与expireAfterWrite
weixin_43928349的博客
06-03 6291
Guava Cache是没有定时的，不会去主动失效key。除非是超过最大的容量，LUA算法才会去移除key。 refreshAfterWrite是指创建指定时间后，没有get过此key， 没有被LUA淘汰删除key，那么此时缓存里面是有旧值的。get时候会进行同步更新旧值的内容，其他线程等待。 LUA淘汰删除key，那么此时缓存里面没有值的。get时候会进行同步新增值内容，其他线程等待。 expireAfterWrite是指创建指定时间后，没有get过此key， 没有被LUA淘汰删除key，那么此时
Cache Guava refreshAfterWrite主动刷新缓存
NOAH_123456的博客
05-09 690
【代码】Cache Guava refreshAfterWrite主动刷新缓存。
详解Guava Cache本地缓存在Spring Boot应用中的实践
08-26
详解Guava Cache本地缓存在Spring Boot应用中的实践 在高并发的互联网应用中，缓存的地位举足轻重，对提升程序性能帮助不小。Spring Boot默认使用的是SimpleCacheConfiguration，即使用ConcurrentMapCacheManager来...
Springboot整合GuavaCache缓存过程解析
08-25
SpringBoot整合GuavaCache缓存过程解析 SpringBoot是一款流行的Java框架，提供了许多便捷的功能来简化开发过程。其中，缓存机制是SpringBoot中的一个重要组件，可以帮助提高应用程序的性能和响应速度。GuavaCache是...
SpringBoot加入Guava Cache实现本地缓存代码实例
08-25
SpringBoot 中 Guava Cache 的应用 在本文中，我们将介绍如何在 SpringBoot 项目中使用 Guava Cache 实现本地缓存。Guava Cache 是一个高性能的缓存框架，由 Google 开发维护。它提供了一个灵活的缓存机制，可以...
Guava-Cache本地缓存案例代码
01-19
Guava Cache是Google Guava库中的一个强大特性，它提供了高效的本地缓存解决方案，用于存储经常访问的数据，以减少对远程服务或计算的调用，从而提高应用性能。本案例代码将详细介绍Guava Cache的使用，包括缓存的...
guava-cache.rar
04-05
Guava Cache支持惰性加载，即当尝试获取一个不存在的键对应的值时，会自动调用预设的`CacheLoader`来计算并存储该值。上述代码中的`createExpensiveGraph`方法就是一个典型的计算逻辑。 3. **缓存统计** Guava ...
Guava refreshAfterWrite只阻塞回源线程，其他线程返回旧值
taoy86的博客
09-30 632
上一篇文章"Guava Cache特性：对于同一个key，只让一个请求回源load数据，其他线程阻塞等待结果"提到：如果缓存过期，恰好有多个线程读取同一个key的值，那么guava只允许一个线程去加载数据，其余线程阻塞。这虽然可以防止大量请求穿透缓存，但是效率低下。使用refreshAfterWrite可以做到：只阻塞加载数据的线程，其余线程返回旧数据。 public class GuavaCache4TestRefresh { private static CountDownLatch latch
Guava Cache LoadingCache 之 refreshAfterWrites和expireAfterWrite区别 使用说明
fengbin2005的专栏
07-15 6430
三种基于时间清理或刷新缓存数据的方式： expireAfterAccess: 当缓存项在指定的时间段内没有被读或写就会被回收。 expireAfterWrite：当缓存项在指定的时间段内没有更新就会被回收（移除key），需要等待获取新值才会返回。 refreshAfterWrite：当缓存项上一次更新操作之后的多久会被刷新。第一个请求进来，执行load把数据加载到内存中（同步过程），指定的过期时间内比如10秒，都是从cache里读取数据。过了10秒后，没有请求进来，不会移除key。再有请求过来，才则执行
guava缓存批量获取的一个坑
赶路人儿
09-03 2615
摘要 Guava Cache是Google开源的Java工具集库Guava里的一款缓存工具，一直觉得使用起来比较简单，没想到这次居然还踩了一个坑 背景 功能需求抽象出来很简单，就是将数据库的查询sthMapper.findById(Long id)的结果缓存起来。但同时还有批量请求，为了提高效率，肯定要批量查询数据库，sthMapper.findByIds(Collection<Long> ids) 对于的guava cache 处理类 // 定义guava缓存 public
Guava Cache LoadingCache 之 refreshAfterWrites和expireAfterWrite区别_loadingcache refreshafterwrite
最新发布
2401_84978642的博客
05-15 362
当缓存项在指定的时间段内没有被读或写就会被回收。：当缓存项在指定的时间段内没有更新就会被回收（移除key），需要等待获取新值才会返回。：当缓存项上一次更新操作之后的多久会被刷新。第一个请求进来，执行load把数据加载到内存中（同步过程），指定的过期时间内比如10秒，都是从cache里读取数据。过了10秒后，没有请求进来，不会移除key。再有请求过来，才则执行reload，在后台异步刷新的过程中，如果当前是刷新状态，访问到的是旧值。
Guava Cache expireAfterWrite 与 refreshAfterWrite区别
codingtu的博客
02-17 2万+
前面的文章缓存篇（一）- Guava有讲到Guava Cache有区别于ConcurrentHashMap的使用，就是因为其自带有自动刷新和自动失效的功能，避免我们去自己编写刷新和失效的后台线程程序。Guava Cache提供了简单便捷的api给我们使用，但是研究源码发现这里的自动刷新缓存和自动失效原理，并非是Guava Cache帮我们去添加了类似后台线程自动刷新或失效逻辑的代码，而是用另外一种...
guava cache
08-18
Guava Cache是Google提供的一套Java工具包中的一部分，它是一套非常完善的本地缓存机制（JVM缓存）。它的设计灵感来源于ConcurrentHashMap，可以按照多种策略来清理存储在其中的缓存值，同时保持很高的并发读写性能。在使用Guava Cache时，可以通过get()或者put()等方法进行缓存操作，当进行这些操作时，Guava Cache会进行惰性删除，即在获取或者放置缓存的时候判断缓存是否过期并进行删除。在Guava Cache的核心原理中，使用Segment来进行缓存值的定位和管理。在创建Guava Cache对象时，可以使用CacheLoader来自动加载数据到缓存中，当缓存不存在时，CacheLoader会负责获取数据并将其放置到缓存中。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [[由零开始]Guava Cache介绍和用法](https://blog.csdn.net/qq497811258/article/details/108260969)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [Guava Cache简介、应用场景分析、代码实现以及核心的原理](https://blog.csdn.net/weixin_44795847/article/details/123702038)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值