Guava Cache介绍-面试用

这篇具有很好参考价值的文章主要介绍了Guava Cache介绍-面试用。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、Guava Cache简介

1、简介

Guava Cache是本地缓存,数据读写都在一个进程内,相对于分布式缓存redis,不需要网络传输的过程,访问速度很快,同时也受到 JVM 内存的制约,无法在数据量较多的场景下使用。

基于以上特点,本地缓存的主要应用场景为以下几种:

  1. 对于访问速度有较大要求
  2. 存储的数据不经常变化
  3. 数据量不大,占用内存较小
  4. 需要访问整个集合
  5. 能够容忍数据不是实时的

2、对比

二、Guava Cache使用

下面介绍如何使用
1、先引入jar

<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>27.0-jre</version>
</dependency>

案例1

1、创建Cache对象,在使用中,我们只需要操作loadingCache对象就可以了。

LoadingCache<String, String> loadingCache = CacheBuilder.newBuilder()
        .initialCapacity(5)//内部哈希表的最小容量,也就是cache的初始容量。
        .concurrencyLevel(3)//并发等级,也可以定义为同时操作缓存的线程数,这个影响segment的数组长度,原理是当前数组长度为1如果小于并发等级且素组长度乘以20小于最大缓存数也就是10000,那么数组长度就+1,依次循环
        .maximumSize(10000)//cache的最大缓存数。应该是数组长度+链表上所有的元素的总数
        .expireAfterWrite(20L, TimeUnit.SECONDS)//过期时间,过期就会触发load方法
        .build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) {
                //缓存不存在,会进到load方法,该方法返回值就是最终要缓存的数据。
                log.info("进入load缓存");
                return "手机号";
            }
        });

2、通过缓存获取数据

//获取缓存,如果数据不存在,触发load方法。
loadingCache.get(key);

案例2:使用reload功能

1、生成缓存对象

ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());

LoadingCache<String, String> loadingCache = CacheBuilder.newBuilder()
        .initialCapacity(5)
        .concurrencyLevel(3)
        .maximumSize(10000)
        .expireAfterWrite(20L, TimeUnit.SECONDS)//超这个时间,触发的是load方法
        .refreshAfterWrite(5L, TimeUnit.SECONDS) //刷新,超过触发的是reload方法
        //.expireAfterAccess(...): //当缓存项在指定的时间段内没有被读或写就会被回收。
        .build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) {
                //缓存不存在或者缓存超过expireAfterWrite设置的时间,进到load方法
                log.info("进入load缓存");
                return "手机号";
            }

            @Override
            public ListenableFuture<String> reload(String key, String oldValue) throws Exception {
                //超过refreshAfterWrite时间,但是没有超过expireAfterWrite时间,进到reload方法
                log.info("进入reload缓存");
				
                //这里是异步执行任务
                return executorService.submit(() ->  {
                    Thread.sleep(1000L);
                    return "relad手机号";
                });
            }
        });

1、expireAfterWrite、refreshAfterWrite可以同时一起使用当然,不同组合应对不同场景。
2、需要说明,当缓存时间当超过refreshAfterWrite时间,但是小于expireAfterWrite设置的时间,请求进来执行的是reload方法,当时间超过expireAfterWrite时间,那么执行的是load方法。

2、使用缓存对象

String value = loadingCache.get(key); //获取缓存
loadingCache.invalidate(key); //删除具体某个key的缓存
loadingCache.invalidateAll(Arrays.asList("key1","key2","key3"));//删除多个
loadingCache.invalidateAll(); //删除所有

三、源码

缓存对象底层是LocalLoadingCache类,里面有个很重要的属性segments,缓存数据都存在这个里面

//1、缓存对象
LocalLoadingCache{
	//segments是一个数组,每一个元素都是Segment类型
	final Segment<K, V>[] segments;	
}

//2、下面介绍下Segment这个类有哪些重要的属性
class Segment<K, V> extends ReentrantLock{ //继承了重入锁
	//首先Segment里面有一个属性table,这个table是AtomicReferenceArray类型
	AtomicReferenceArray<ReferenceEntry<K, V>> table;
}

//3、下面看下AtomicReferenceArray到底有什么
AtomicReferenceArray{
	//其实就是包裹了一个数组。每个元素都ReferenceEntry类型
	private final Object[] array;
}

AtomicReferenceArray特别之处在于下

提供了可以原子读取、写入,底层引用数组的操作,并且还包含高级原子操作。比较特别的就是put操作,就是我们在给该数组某个元素设置值的时候可以使用比较的方式来设置值。
例如:AtomicReferenceArray.compareAndSet(2,10,20)
2下标位置,10是新的值,20是原来期望的值,只有原来的值为20才会更新为10。

在回到上面AtomicReferenceArray里面的属性array里面每一个元素都是ReferenceEntry类型,ReferenceEntry的实现类是StrongAccessWriteEntry

StrongAccessWriteEntry{
	final K key;
	//value存到了ValueReference对象里面,只是ValueReference包装了一下,这个在并发的时候会用到。
	volatile ValueReference<K, V> value; 
	final int hash;
	final ReferenceEntry<K, V> next;    //针对hash碰撞时拓展的链表。	
}

结构图如下:

Guava Cache介绍-面试用,缓存框架,guava,cache,过期策略

四、下面介绍常用功能及其原理

1、获取数据

1、通过key生成hash,根据hash从segments这个数组中得到具体下标,该元素是Segment类型
2、从Segment里面的table里面获取,也就是AtomicReferenceArray的array从里面获取数据,此时拿到的是一个key所对应的StrongAccessWriteEntry对象。
3、StrongAccessWriteEntry里面会存下该hash碰撞所对应的其他key-value数据集合,StrongAccessWriteEntry对象保存了这个元素所对应的hash,key,和value,next,还有过期时间,如果过期了也会返回return, 如果没有过期,会进行key对比,只有一致才会返回。
4、获取的时候,如果数据不存在就会调用下面的put方法。获取数据时是不使用lock()的。

2、put数据

在put前先lock(),为什么可以使用锁,因为继承了ReentrantLock

Segment<K, V> extends ReentrantLock {
	.....
}

首先是通过Load方法拿到数据,拿到后再通过storeLoadedValue方法来把结果写到缓存数据里面去,在写入的时候,也是用到了锁lock(); 所以这里就双重锁了。
先是通过hash结合算法,得到下标,在根据下标从AtomicReferenceArray数组中获取元素,那么这个元素ReferenceEntry是一个有next的链表,所以我们要遍历,这个链表,如果有key一致的,我么就要把他覆盖掉。如果没有就使用set方法设置值。

3、删除数据

删除数据也是一样,先lock();
拿到找到这个元素所在的位置,然后删除掉

4、过期策略(重点)

过期配置主要包含着三个expireAfterWrite、refreshAfterWrite、expireAfterAccess,下面分别介绍下这个三个作用

expireAfterWrite:当缓存项在指定时间后就会被回收(主动),需要等待获取新值才会返回。
expireAfterAccess: 当缓存项在指定的时间段内没有被读或写就会被回收。
refreshAfterWrite:设置缓存刷新时间。举个例子:第一次请求进来,执行load把数据加载到内存中(同步过程),假设指定的刷新时间是10秒,前10秒内都是从cache里读取数据。过了10秒后,没有请求进来,不会移除key。再有请求过来,才则执行reload(异步调用),在后台异步刷新的过程中,所以本次访问到的是旧值。刷新过程中只有一个线程在执行刷新操作,不会出现多个线程同时刷新同一个key的缓存。在吞吐量很低的情况下,如很长一段时间内没有请求,再次请求有可能会得到一个旧值(这个旧值可能还是很久之前的数据),这就会有问题。(可以使用expireAfterWrite和refreshAfterWrite搭配使用解决这个问题)。在设置了expireAfterWrite后,如果超过expire时间,走的就是load方法,这是实时去获取数据。

//是否更新过期时间判断条件,只要创建缓存对象时设置了"刷新时间"、"过期时间"都会更新时间
void recordWrite(ReferenceEntry<K, V> entry, int weight, long now) {
    drainRecencyQueue();
    totalWeight += weight;

    if (map.recordsAccess()) {    //这个判断条件是expireAfterAccess>0
        entry.setAccessTime(now);   //设置过期时间
    }
    if (map.recordsWrite()) {        //这个判断条件是expireAfterWrite>0
        entry.setWriteTime(now);   //设置过期时间
    }
    accessQueue.add(entry);
    writeQueue.add(entry);
}

如果存在设置了expireAfterAccess时间每次读的时候,都会更新过期时间

if (map.recordsAccess()) {
    entry.setAccessTime(now);
}

那么在获取数据的时候,是如何判断是否执行reload的,源码里面有明确的判断

V scheduleRefresh(ReferenceEntry<K, V> entry, K key, int hash, V oldValue, long now, CacheLoader<? super K, V> loader) {
    if (map.refreshes() && (now - entry.getWriteTime() > map.refreshNanos)) {
        V newValue = refresh(key, hash, loader, true);
    }
}
//map.refreshes()主要是判断 refreshNanos > 0
//也就是代码中build的refreshAfterWrite(2L, TimeUnit.MINUTES)代码。设置了refreshNanos的时间。

场景1: 当前时间减去缓存到期时间结果大于过期时间,才会执行refresh方法,就会从reload里面获取数据。
场景2:当然还有一种情况就是既设置了refreshAfterWrite,又设置了expireAfterWrite,这个情况是,优先判断,数据是否过期了,如果并且过期时间超了,那么就执行load方法,如果没有超过过期时间,超过了refresh的过期时间,那么就执行reload方法,代码如下

//判断是否过期
if (map.isExpired(entry, now)) {
    return null;
}
//看下isExpired的逻辑
boolean isExpired(ReferenceEntry<K, V> entry, long now) {
	//这里忽略
    if (expiresAfterAccess() && (now - entry.getAccessTime() >= expireAfterAccessNanos)) {
        return true;
    }
    //判断是否设置了expireAfterWriteNanos时间,且当前时间减去过期时间是否超过expireAfterWriteNanos,超过则说明数据已经过期了。
    if (expiresAfterWrite() && (now - entry.getWriteTime() >= expireAfterWriteNanos)) {
        return true;
    }
    return false;
}

2、解决缓存击穿

缓存击穿:假如在缓存过期的那一瞬间,有大量的并发请求过来。他们都会因缓存失效而去加载执行db操作,可能会给db造成毁灭性打击。

解决方案: 采用expireAfterWrite+refreshAfterWrite 组合设置来防止缓存击穿,expire则通过一个加锁的方式,只允许一个线程去回源,有效防止了缓存击穿,但是可以从源代码看出,在有效防止缓存击穿的同时,会发现多线程的请求同样key的情况下,一部分线程在waitforvalue,而另一部分线程在reentantloack的阻塞中。

//当数据过期了,先拿到数据的状态,如果是正在执行load方法,则其他线程就先等待,
ValueReference<K, V> valueReference = e.getValueReference();
if (valueReference.isLoading()) {
    return waitForLoadingValue(e, key, valueReference);
}
//关键在于valueReference对象,他有2种两类,不同类型代表不同状态。

1、一开始创建的时候valueReference是LoadingValueReference类型对象。这个在刚创建entity的时候会用到。也就是load方法被执行前LoadingValueReference固定是返回true

2、当load方法被加载完valueReference类型就变成StrongValueReference。load执行完后,更新entity的类型。StrongValueReference的isLoading方法固定是false
3、当数据过期时

3、刷新时拿到的不一定是最新数据

因为如果因为过期执行刷新的方法也就是reload方法,那么从缓存里面拿到的数据不一定是新数据,可能是老数据,为什么,因为刷新时异步触发reload,不像load同步这种,源码如果reload的返回null,那么会优先使用oldValue数据。

V scheduleRefresh(ReferenceEntry<K, V> entry, K key, int hash, V oldValue, long now, CacheLoader<? super K, V> loader) {
    if (map.refreshes() && (now - entry.getWriteTime() > map.refreshNanos)) {
        V newValue = refresh(key, hash, loader, true); //执行刷新的方法,也就reload方法,下面看下refresh做了什么操作
        if (newValue != null) {
            return newValue;
        }
    }
    return oldValue;
}

refresh(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime) {
    //通过异步去执行reload方法,注意是异步,此时没有完成,那么直接返回null,那么上面的scheduleRefresh方法直接返回的是oldValue,也就是老数据。
    ListenableFuture<V> result = loadAsync(key, hash, loadingValueReference, loader);
    if (result.isDone()) {
        try {
            return Uninterruptibles.getUninterruptibly(result);
        } catch (Throwable t) {

        }
    }
    return null;
}

所以缓存失效第一次数据不一定是最新的数据。可能是老的数据,因为是异步执行reload方法不知道耗时会有多久,所以主线程不会一直去等子线程完成。关注下,主线程在子线程执行reload会等多久?

4、总结

1、refreshAfterWrites是异步去刷新缓存的方法,可能会使用过期的旧值快速响应。

2、expireAfterWrites缓存失效后线程需要同步等待加载结果,可能会造成请求大量堆积的问题。

四、注意点

在重写load的时候,如果数据是空要写成"",不能是null,因为在put的时候,会判断返回的值如果是null就会抛出下面异常文章来源地址https://www.toymoban.com/news/detail-731863.html

@Override
public String load(String key) {
    return ...
}

//当load返回为空时会抛出异常
if (value == null) {
  throw new InvalidCacheLoadException("CacheLoader returned null for key " + key + ".");
}

到了这里,关于Guava Cache介绍-面试用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • flink1.15 维表join guava cache和mysql方面优化

    优化前  mysql响应慢,导致算子中数据输出追不上输入,导致显示cpu busy:100% 优化后效果两个图对应两个时刻: - - 图中guava cache命中率是通过guava自带统计,打印出来的. 1 guava缓存数据量上限 = 类中配置的guava缓存数据上线 * task个数(即flink并行度) 缓存越久 命中率越高 数据越陈旧

    2024年01月17日
    浏览(36)
  • Spring Cache框架(缓存)

    1、介绍: Spring Cache 是一个框架,实现了基于注解的缓存功能,只需要简单加个注解,就能实现缓存功能。它提供了一层抽象,底层可以切换不同的cache实现。具体就是通过 CacheManager 接口来实现不同的缓存技术。 针对不同的混存技术需要实现不同的 CacheManage r: CacheManager 描述

    2024年02月11日
    浏览(58)
  • Spring | Spring Cache 缓存框架

    Spring Cache 是 Spring 的一个框架, 实现了基于注解的缓存功能 。只需简单加一个 注解 ,就能实现 缓存功能 。 Spring Cache提供了一层抽象 , 底层可以切换不同的缓存实现 。比较 常见 的(底层) 缓存实现 有: Redis、EHCache、Caffeine 。可自定义地修改 Spring Cache 底层的 缓存实现 。

    2024年02月08日
    浏览(44)
  • Google的guava缓存学习使用

    导入依赖 使用1 项目中使用到了缓存,定义一个切面,拦截类或方法上存在@SysDataCache注解请求,对于这些方法的返回值进行缓存。项目中主要还是使用在缓存常量,一些不易改变的值 定义注解 定义切面和初始化缓存容器并使用缓存 项目中缓存使用 使用2 作为性能缓存工具,

    2024年01月25日
    浏览(43)
  • 【java缓存、redis缓存、guava缓存】java中实现缓存的几种方式

    这种方式可以简单实现本地缓存,但是实际开发中不推荐使用,下面我们来实现一下这种方式。 首先创建一个管理缓存的类 这个类中有一个静态代码块,静态代码块会在类加载时就执行,我们可以在这里完成对缓存的初始化,决定缓存内一开始就有哪些数据 另外我们还可以

    2024年02月16日
    浏览(34)
  • 【Redis(8)】Spring Boot整合Redis和Guava,解决缓存穿透、缓存击穿、缓存雪崩等缓存问题

    在缓存技术的挑战及设计方案我们介绍了使用缓存技术可能会遇到的一些问题,那么如何解决这些问题呢? 在构建缓存系统时,Spring Boot和Redis的结合提供了强大的支持,而Guava的 LoadingCache 则为缓存管理带来了便捷的解决方案。下面我将介绍如何通过整合Spring Boot、Redis和Gu

    2024年04月22日
    浏览(48)
  • 【译】Google Guava 的 Table 接口介绍

    原文:https://www.baeldung.com/guava-table 在本教程中,我们将展示如何使用 Google Guava 的 Table 接口及其多个实现。 Guava 的 Table 是一种集合,表示包含行、列和相关单元格值的表结构,行和列充当有序的键对。 让我们看看如何使用 Table 类。 2.1. Maven依赖 首先,在 pom.xml 中添加 Goo

    2024年02月06日
    浏览(36)
  • 重试框架入门:Spring-Retry&Guava-Retry

    在日常工作中,随着业务日渐庞大,不可避免的涉及到调用远程服务,但是远程服务的健壮性和网络稳定性都是不可控因素,因此,我们需要考虑合适的重试机制去处理这些问题,最基础的方式就是手动重试,侵入业务代码去处理,再高端一点的通过切面去处理,较为优雅的

    2024年02月13日
    浏览(43)
  • Buffer(缓冲)、Cache(缓存)

    Buffer 用途:缓冲通常用于临时存储数据,以平衡不同速度的数据传输过程直接的差异。它可以用来解决数据传输速度不匹配的问题。 例如: 当您在观看视频时,视频播放器会缓冲一段时间的视频数据,以便在网络速度慢或不稳定的情况下也能够流畅的播放 用完之后,就清除

    2024年02月03日
    浏览(48)
  • SpringBoot Cache缓存

    application.properties配置文件 ehcache.xml配置文件 name:cache的名字,必须惟一。 eternal:是否持久化,若为true,则表示缓存元素不会过期。 maxElementsInMemory:cache中最多可以存放的元素的数量。 overflowToDisk:溢出是否写入磁盘。 diskPersistent:是否持久化磁盘缓存。 timeToIdleSeconds:访

    2024年01月18日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包