Guava系列之Cache

Myth丶恋晨 2023-02-18 09:35 24阅读 0赞

缓存是日常开发中使用很频繁的一种提升性能的方式，它其实解决的是硬件层面性能不对等的问题，比如CPU、内存、硬盘之间性能的巨大差异，会严重影响数据的读取与传输，而缓存就是用来平衡这种性能差异的手段

缓存在很多系统和架构中广泛使用，如：

*  CPU缓存
 *  操作系统缓存
 *  数据库缓存
 *  分布式缓存
 *  本地缓存

**日常开发中的使用场景**

在我们日常的开发中，当多次获取同一份数据而数据变化不频繁时，我们可以考虑使用缓存。

这里用到的就是内存和硬盘的性能不对等，我们知道内存的读取速度很快，而硬盘相对来说比较慢

而传统的关系型数据库把数据存储在硬盘上，这样在高并发读写的场景下，就会出现性能瓶颈

这个时候，如果在数据库前面加一层缓存，把数据库里面的热点数据缓存一份到内存中，读取的时候直接从内存中取，这样就可以大大的提升读取的性能

#### Guava中的缓存实现 ####

Guava中的缓存是本地缓存的实现，与ConcurrentMap相似，但不完全一样。最基本的区别就是，ConcurrentMap会一直保存添加进去的元素，除非你主动remove掉。而Guava Cache为了限制内存的使用，通常都会设置自动回收

Guava Cache的使用场景：

*  以空间换取时间，就是你愿意用内存的消耗来换取读取性能的提升
 *  你已经预测到某些数据会被频繁的查询
 *  缓存中存放的数据不会超过内存空间

**示例代码**

@Test
        public void cacheCreateTest(){ 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .maximumSize(100) //设置缓存最大容量
                    .expireAfterWrite(1,TimeUnit.MINUTES) //过期策略，写入一分钟后过期
                    .build();
            cache.put("a","a1");
            String value = cache.getIfPresent("a");
        }

#### Cache ####

Cache是Guava提供的最基本缓存接口，创建一个Cache很简单

Cache是通过CacheBuilder对象来build出来的，build之前可以设置一系列的参数

#### LoadingCache ####

LoadingCache继承自Cache,当从缓存中读取某个key时，假如没有读取到值，LoadingCache会自动进行加载数据到缓存

@Test
        public void loadingCacheTest() throws ExecutionException { 
            LoadingCache<String,String> loadingCache = CacheBuilder.newBuilder()
                    .maximumSize(3)
                    .refreshAfterWrite(Duration.ofMillis(10))//10分钟后刷新缓存的数据
                    .build(new CacheLoader<String, String>() { 
                        @Override
                        public String load(String key) throws Exception { 
                            Thread.sleep(1000);
                            System.out.println(key + " load data");
                            return key + " add value";
                        }
                    });
            System.out.println(loadingCache.get("a"));
            System.out.println(loadingCache.get("b"));
        }

运行结果：

a load data
    a add value
    b load data
    b add value

LoadingCache也是通过CacheBuilder创建出来的，只不过创建的时候，需要在build方法里面传入CacheLoader

CacheLoader类的load方法就是在key找不到的情况下，进行数据自动加载的

#### Cache常用参数 ####

下面我们看一下Guava Cache在使用时常用的属性，下面的属性对Cache和LoadingCache都适用

**1、容量初始化**

public void initialCapacityTest(){ 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .initialCapacity(1024) //初始容量
                    .build();
        }

**2、最大容量**

最大容量可以通过两种维度来设置

*  maximumSize 最大记录数，存储数据的个数
 *  maximumWeight 最大容量，存储数据的大小

@Test
        public void maxSizeTest(){ 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .maximumSize(2)//缓存最大个数
                    .build();
            cache.put("a","1");
            cache.put("b","2");
            cache.put("c","3");
    
            System.out.println(cache.getIfPresent("a"));
            System.out.println(cache.getIfPresent("b"));
            System.out.println(cache.getIfPresent("c"));
    
            Cache<String,String> cache1 = CacheBuilder.newBuilder()
                    .maximumWeight(1024 * 1024 * 1024)//最大容量为1M
                    //用来计算容量的Weigher
                    .weigher(new Weigher<String, String>() { 
                        @Override
                        public int weigh(String key, String value) { 
                            return key.getBytes().length + value.getBytes().length;
                        }
                    })
                    .build();
            cache1.put("x","1");
            cache1.put("y","2");
            cache1.put("z","3");
    
            System.out.println(cache1.getIfPresent("x"));
            System.out.println(cache1.getIfPresent("y"));
            System.out.println(cache1.getIfPresent("z"));
    
        }

运行结果：

null
    2
    3
    1
    2
    3

我们设置缓存的最大记录为2，当我们添加三个元素进去后，会把前面添加的元素覆盖

**3、过期时间**

*  expireAfterWrite 写入后多长时间，数据就过期了
 *  expireAfterAccess 数据多长时间没有被访问，就过期

@Test
        public void expireTest() throws InterruptedException { 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .maximumSize(100)//缓存最大个数
                    .expireAfterWrite(5,TimeUnit.SECONDS)//写入后5分钟过期
                    .build();
            cache.put("a","1");
            int i = 1;
            while(true){ 
                System.out.println("第" + i + "秒获取到的数据为：" + cache.getIfPresent("a"));
                i++;
                Thread.sleep(1000);
            }
        }

运行结果

第1秒获取到的数据为：1
    第2秒获取到的数据为：1
    第3秒获取到的数据为：1
    第4秒获取到的数据为：1
    第5秒获取到的数据为：1
    第6秒获取到的数据为：null
    第7秒获取到的数据为：null
    第8秒获取到的数据为：null
    第9秒获取到的数据为：null

从运行结果可以看出来，写入数据后的第6秒就开始获取不到数据了

@Test
        public void expireAfterAccessTest() throws InterruptedException { 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .maximumSize(100)//缓存最大个数
                    .expireAfterAccess(5,TimeUnit.SECONDS)//5秒没有被访问，就过期
                    .build();
            cache.put("a","1");
            Thread.sleep(3000);
            System.out.println("休眠3秒后访问：" + cache.getIfPresent("a"));
            Thread.sleep(4000);
            System.out.println("休眠4秒后访问：" + cache.getIfPresent("a"));
            Thread.sleep(5000);
            System.out.println("休眠5秒后访问：" + cache.getIfPresent("a"));
    
        }

运行结果：

休眠3秒后访问：1
    休眠4秒后访问：1
    休眠5秒后访问：null

从运行结果可以看出，只要超过了设定的时间没有人访问，缓存的数据就会过期

#### 回收策略 ####

在上面我们讲了两种回收策略

*  expireAfterWrite 写入多长时间后就回收
 *  expireAfterAccess 多长时间没有被访问就回收

Guava Cache还支持基于引用级别的回收，这种回收策略是Java特有的，在Java的对象回收机制中，按对象的强弱可以分为强引用、软引用、弱引用、虚引用

**强引用**

强引用是我们最常用的引用，比如我们直接new一个对象，就是一个强引用

Map<String,String> map = new HashMap<String,String>();

强引用不会被自动回收，当内存不足时直接报内存溢出

**软引用**

软引用是一种不稳定的引用方式，如果一个对象具有软引用，当内存充足时，GC不会主动回收软引用对象，而当内存不足时软引用对象就会被回收

SoftReference<Object> softRef=new SoftReference<Object>(new Object()); // 软引用
    Object object = softRef.get(); // 获取软引用

**弱引用**

弱引用是一种比软引用更不稳定的引用方式，因为无论内存是否充足，弱引用对象都有可能被回收

WeakReference<Object> weakRef = new WeakReference<Object>(new Object()); 
    Object obj = weakRef.get(); // 获取弱引用

**虚引用**

虚引用这种引用方式就是形同虚设，因为如果一个对象仅持有虚引用，那么它就和没有任何引用一样。在实践中也几乎没有使用

在Guava中支持软/弱引用的回收方式

Cache<String,String> cache = CacheBuilder.newBuilder()
                    .weakKeys() //使用弱引用存储键。当键没有其它（强或软）引用时，该缓存可能会被回收。
                    .weakValues() //使用弱引用存储值。当值没有其它（强或软）引用时，该缓存可能会被回收。
                    .softValues() //使用软引用存储值。当内存不足并且该值其它强引用引用时，该缓存就会被回收
                    .build();

**手动回收**

上面讲的都是缓存自动回收的策略，我们也可以调用Guava Cache提供的方法来手动清除

可以删除单个key，也可以批量删除key，同时也可以清除整个缓存的数据（谨慎使用哦~）

@Test
        public void invalidateTest(){ 
            Cache<String,String> cache = CacheBuilder.newBuilder().build();
            cache.put("a","1");
            cache.put("b","2");
            //从缓存中清除key为a的数据
            cache.invalidate("a");
            System.out.println(cache.getIfPresent("a"));
    
            cache.put("x","x1");
            cache.put("y","y1");
            System.out.println("x清除之前："+ cache.getIfPresent("x"));
            System.out.println("y清除之前："+ cache.getIfPresent("y"));
            List<String> list = Lists.newArrayList("x","y");
            //批量清除
            cache.invalidateAll(list);
            System.out.println("x清除之后："+ cache.getIfPresent("x"));
            System.out.println("y清除之后："+ cache.getIfPresent("y"));
    
            cache.put("y","y1");
            cache.put("z","z1");
    
            //清空缓存所有的数据
            cache.invalidateAll();
    
            System.out.println("全部清除后：" + cache.getIfPresent("y"));
            System.out.println("全部清除后：" + cache.getIfPresent("z"));
    
        }

运行结果：

null
    x清除之前：x1
    y清除之前：y1
    x清除之后：null
    y清除之后：null
    全部清除后：null
    全部清除后：null

#### 数据清除监听器 ####

可以给Cache中的对象加一个监听，当有对象被删除时会有事件通知

@Test
        public void removeListenerTest() throws InterruptedException { 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .maximumSize(3)
                    .expireAfterWrite(Duration.ofSeconds(5))//5秒后自动过期
                    //添加一个remove的监听器
                    .removalListener(new RemovalListener<Object, Object>() { 
    
                        @Override
                        public void onRemoval(RemovalNotification<Object, Object> notification) { 
                            System.out.println("[" +notification.getKey() + ":" + notification.getValue() + "] 被删除了");
                        }
                    })
                    .build();
    
            cache.put("a","1");
            Thread.sleep(2000);
            cache.put("b","2");
            cache.put("c","3");
            Thread.sleep(2000);
            cache.put("d","4");
            Thread.sleep(5000);
            cache.put("e","5");
            cache.invalidate("e");
    
        }

运行结果：

[a:1] 被删除了
    [b:2] 被删除了
    [c:3] 被删除了
    [d:4] 被删除了
    [e:5] 被删除了

创建Cache时removalListener方法传入一个RemovalListener对象，重写onRemoval方法来进行数据清除事件的监听

从运行结果可以看出来，三种情况下的清除数据都会被监听

*  超过容量，清除最早添加进缓存的数据
 *  超过设定的过期时间，缓存系统自动删除
 *  手动清除数据

#### 统计信息 ####

我们在使用缓存的时候，应该要关心缓存的命中率、加载数据时间等等信息，可以根据这些统计信息来对缓存进行优化调整，让缓存更好的为我们服务。在构建缓存对象时，可以开启统计信息，开启后会对缓存的操作进行统计

@Test
        public void recordStatsTest(){ 
            Cache<String,String> cache = CacheBuilder.newBuilder()
                    .maximumSize(3)
                    .recordStats()
                    .build();
            cache.put("a","1");
            cache.put("b","2");
            cache.put("c","3");
            cache.put("d","4");
            cache.put("e","5");
            cache.put("f","6");
    
            cache.getIfPresent("a");
            cache.getIfPresent("a");
            cache.getIfPresent("e");
            cache.getIfPresent("f");
            cache.getIfPresent("h");
            cache.getIfPresent("t");
            System.out.println(cache.stats());
        }

运行结果：

CacheStats{ hitCount=2, missCount=4, loadSuccessCount=0, loadExceptionCount=0, totalLoadTime=0, evictionCount=3}

参考：

https://www.cnblogs.com/fnlingnzb-learner/p/11022152.html

https://blog.csdn.net/l1028386804/article/details/102764951

> 如果感觉对你有些帮忙，想跟我一起学习，坚信技术改变世界，请关注Java天堂公众号，我会定期分享自己的学习成果，第一时间推送给你

![在这里插入图片描述][20200528221140804.jpg_pic_center_pic_center_pic_center_pic_center]

[20200528221140804.jpg_pic_center_pic_center_pic_center_pic_center]: https://img-blog.csdnimg.cn/20200528221140804.jpg#pic_center#pic_center#pic_center#pic_center