guava：LoadingCache。

分手后的思念是犯贱 2022-12-20 01:53 134阅读 0赞

缓存的使用可以大大提高程序的执行效率，但是如果缓存无法及时更新会导致脏读的情况。

# 痛点剖析 #

记得早期我呆过的一家公司有个核心服务是在启动的时候一下把常用的交易配置信息是从DB查出来放在Map里面来做缓存，先不考虑其他的，如果我想更新一下交易配置信息是不是需要每次都重启服务器呢，又或者说我开几个后门接口用来更新Map信息，这样不还得考虑线程安全的问题么。

好吧，我先上个在中小型项目中，乃至大型项目中也常用的缓存架构，如下：

![17702b610149151b95d46edfcc41bd11.webp][]

# 内存架构图 #

我大概解释一下流程吧：

1.  系统A中使用LoadingCache来维护本地缓存信息
2.  当缓存刷新时(**同步、异步）**调用B系统来更新缓存信息
3.  系统B接收A获取配置数据的请求，如果redis缓存中有数据就直接从redis中拿
4.  当缓存中不存在请求则穿透到DB里面查询再将结果塞到redis，并返回结果
5.  其实还有一步没画出来应该是有个定时job轮询DB配置信息变化时刷新redis信息(或者消息机制来实现缓存更新)

言归正传，下面来详解一下LoadingCache的使用：

public static LoadingCache<String,String> cahceBuilder = CacheBuilder.newBuilder().maximumSize(1).
    // expireAfterWrite(1, TimeUnit.SECONDS)
    .refreshAfterWrite(2, TimeUnit.MILLISECONDS).removalListener(new RemovalListener(){
    
        @Override
    
        public void onRemoval(RemovalNotificationrn) {
    
            System.out.println(rn.getKey() + "被移除");
        }
    }).build(new CacheLoader() {
    
        @Override
    
        public String load(String key) throws Exception {
    
            String strProValue = "hello " + key + "!";
    
            System.out.println("%%%%%" + strProValue);
    
            return strProValue;
    
        }
    });
    
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
        cahceBuilder.get("jerry");
    
        cahceBuilder.get("peida");
    
        Thread.sleep(1000);
    
        cahceBuilder.get("jerry1");
    
    }

> 输出结果为：
> 
> %%%%%hello jerry!                            -- 在第一次get的时候没有值会执行load方法，去取值然后塞到本地缓存
> 
> %%%%%hello peida!                          -- 在第一次get的时候没有值会执行load方法，去取值然后塞到本地缓存
> 
> jerry被移除                                      -- maximumSize(1) 最大值为1，当预存储第二个值的时候第一个值会被移除
> 
> %%%%%hello jerry1!                         -- refreshAfterWrite设置2ms自动定时刷新，当有访问时会重新执行load方法更新缓存
> 
> peida被移除                                   -- maximumSize(1) 最大值为1，当预存储第二个值的时候第一个值会被移除

# **方法剖析** #

*  [get(K)][get_K]：这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地loading新值(就是上面说的当缓存没有值的时候执行Load方法)
 *  [put(key, value)][put_key_ value]：这个方法可以直接显示地向缓存中插入值，这会直接覆盖掉已有键之前映射的值。

## **缓存回收** ##

*  [CacheBuilder.maximumSize(long)][CacheBuilder.maximumSize_long]：这个方法规定缓存项的数目不超过固定值(其实你可以理解为一个Map的最大容量)，尝试**回收最近没有使用或总体上很少使用的缓存项**

## **定时回收（Timed Eviction）** ##

*  **expireAfterAccess(long, TimeUnit)**：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。
 *  **expireAfterWrite(long, TimeUnit)**：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。

## **显式清除** ##

任何时候，你都可以显式地清除缓存项，而不是等到它被回收：

*  个别清除：[Cache.invalidate(key)][Cache.invalidate_key]  
 *  批量清除：[Cache.invalidateAll(keys)][Cache.invalidateAll_keys]  
 *  清除所有缓存项：[Cache.invalidateAll()][Cache.invalidateAll]

## **移除监听器** ##

通过[CacheBuilder.removalListener(RemovalListener)][CacheBuilder.removalListener_RemovalListener]，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，[RemovalListener][]会获取移除通知\[[RemovalNotification][]\]，其中包含移除原因\[[RemovalCause][]\]、键和值。

就如我上面的例子一样，当内存回收或者定时回收都会执行[removalListener][CacheBuilder.removalListener_RemovalListener]

不过亲测当有数据refresh刷新额度时候也会触发这个监听功能

警告：默认情况下，监听器方法是在移除缓存时同步调用的。因为缓存的维护和请求响应通常是同时进行的，代价高昂的监听器方法在**同步模式下会拖慢正常的缓存请求**。在这种情况下，你可以使用[RemovalListeners.asynchronous(RemovalListener, Executor)][RemovalListeners.asynchronous_RemovalListener_ Executor]把监听器装饰为**异步操作**。

## 刷新 ##

**这应该会是我重点讲的：**

*  [LoadingCache.refresh(K)][LoadingCache.refresh_K]：刷新和回收不太一样。刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃\[swallowed\]。重载[CacheLoader.reload(K, V)][CacheLoader.reload_K_ V]可以扩展刷新时的行为，这个方法允许开发者在计算新值时使用旧的值。
 *  [CacheBuilder.refreshAfterWrite(long, TimeUnit)][CacheBuilder.refreshAfterWrite_long_ TimeUnit]：可以为缓存增加自动定时刷新功能。和expireAfterWrite相反，refreshAfterWrite通过定时刷新可以让缓存项保持可用，但请注意：缓存项只有在被检索时才会真正刷新，即只有刷新间隔时间到了你再去get(key)才会重新去执行Loading否则就算刷新间隔时间到了也不会执行loading操作。因此，如果你在缓存上同时声明expireAfterWrite和refreshAfterWrite，缓存并不会因为刷新盲目地定时重置，如果缓存项没有被检索，那刷新就不会真的发生，缓存项在过期时间后也变得可以回收。还有一点比较重要的是[refreshAfterWrite][CacheBuilder.refreshAfterWrite_long_ TimeUnit]和expireAfterWrite两个方法设置以后，重新get会引起loading操作都是同步串行的。这其实可能会有一个隐患，当某一个时间点刚好有大量检索过来而且都有刷新或者回收的话，是会产生大量的请求同步调用loading方法，这些请求占用线程资源的时间明显变长。如正常请求也就20ms，当刷新以后加上同步请求loading这个功能接口可能响应时间远远大于20ms。**为了预防这种井喷现象，可以不设置[CacheBuilder.refreshAfterWrite(long, TimeUnit)][CacheBuilder.refreshAfterWrite_long_ TimeUnit]，改用[LoadingCache.refresh(K)][LoadingCache.refresh_K]因为它是异步执行的，不会影响正在读的请求，同时使用[ScheduledExecutorService][]可以帮助你很好地实现这样的定时调度，配上cache.asMap().keySet()返回当前所有已加载键，这样所有的key定时刷新就有了。如果访问量没有这么大则直接用[CacheBuilder.refreshAfterWrite(long, TimeUnit)][CacheBuilder.refreshAfterWrite_long_ TimeUnit]也可以。这个可以评估自己的项目实际情况来决策。**

**还是上代码：**

public class LoadingCacheTest {
    
            private static ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    
            private static class EchoServer implements Runnable {
    
                @Override
    
                public void run() {
    
                    try {
    
                        Set<String> keys = cahceBuilder.asMap().keySet();
    
                        for (String key : keys) {
    
                            cahceBuilder.refresh(key);
    
                        }
    
                    } catch (Exception e) {
    
                    }
    
                }
            }
    
            public static LoadingCachecahceBuilder =CacheBuilder.newBuilder().
    
            maximumSize(10).
    
            removalListener(new RemovalListener() {
    
                @Override
    
                public void onRemoval (RemovalNotificationrn) {
    
                        System.out.println(rn.getKey() + "被移除");
    
            })
            .build(new CacheLoader() {
    
                    @Override
    
                    public String load(String key) throws Exception {
    
                        String strProValue = "hello " + key + "!";
    
                        System.out.println("%%%%%" + strProValue);
    
                        return strProValue;
    
                    }
            });
    
    
            public static void main (String[]args) throws Execution {
    
                    System.out.println(cahceBuilder.get("jerry"));
    
                    System.out.println(cahceBuilder.get("peida"));
    
                    cahceBuilder.get("jerry1");
    
                    executor.scheduleAtFixedRate(new EchoServer(), 0, 1000, TimeUnit.MILLISECONDS);
    
            }
    }

## **其他特性** ##

### 统计 ###

[CacheBuilder.recordStats()][CacheBuilder.recordStats]用来开启Guava Cache的统计功能。统计打开后，[Cache.stats()][Cache.stats]方法会返回[CacheStats][]对象以提供如下统计信息：

*  [hitRate()][hitRate]：缓存命中率；
 *  [averageLoadPenalty()][averageLoadPenalty]：加载新值的平均时间，单位为纳秒；
 *  [evictionCount()][evictionCount]：缓存项被回收的总数，不包括显式清除

此外，还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中我们建议密切关注这些数据。

### **asMap视图** ###

asMap视图提供了缓存的ConcurrentMap形式，但asMap视图与缓存的交互需要注意：

*  cache.asMap()包含当前所有加载到缓存的项。因此相应地，cache.asMap().keySet()包含当前所有已加载键;
 *  asMap().get(key)实质上等同于cache.getIfPresent(key)，而且不会引起缓存项的加载。这和Map的语义约定一致。
 *  所有读写操作都会重置相关缓存项的访问时间，包括Cache.asMap().get(Object)方法和Cache.asMap().put(K, V)方法，但不包括Cache.asMap().containsKey(Object)方法，也不包括在Cache.asMap()的集合视图上的操作。比如，遍历Cache.asMap().entrySet()不会重置缓存项的读取时间。

[17702b610149151b95d46edfcc41bd11.webp]: /images/20221120/107f2cdc371648f18d61b3c02604b70e.png
[get_K]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/LoadingCache.html#get%28K%29
[put_key_ value]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#put%28K,%20V%29
[CacheBuilder.maximumSize_long]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#maximumSize%28long%29
[Cache.invalidate_key]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#invalidate%28java.lang.Object%29
[Cache.invalidateAll_keys]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#invalidateAll%28java.lang.Iterable%29
[Cache.invalidateAll]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#invalidateAll%28%29
[CacheBuilder.removalListener_RemovalListener]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#removalListener%28com.google.common.cache.RemovalListener%29
[RemovalListener]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalListener.html
[RemovalNotification]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalNotification.html
[RemovalCause]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalCause.html
[RemovalListeners.asynchronous_RemovalListener_ Executor]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalListeners.html#asynchronous%28com.google.common.cache.RemovalListener,%20java.util.concurrent.Executor%29
[LoadingCache.refresh_K]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/LoadingCache.html#refresh%28K%29
[CacheLoader.reload_K_ V]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheLoader.html#reload%28K,%20V%29
[CacheBuilder.refreshAfterWrite_long_ TimeUnit]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#refreshAfterWrite%28long,%20java.util.concurrent.TimeUnit%29
[ScheduledExecutorService]: https://link.jianshu.com?t=http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ScheduledExecutorService.html
[CacheBuilder.recordStats]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git-history/release12/javadoc/com/google/common/cache/CacheBuilder.html#recordStats%28%29
[Cache.stats]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#stats%28%29
[CacheStats]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheStats.html
[hitRate]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheStats.html#hitRate%28%29
[averageLoadPenalty]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheStats.html#averageLoadPenalty%28%29
[evictionCount]: https://link.jianshu.com?t=http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheStats.html#evictionCount%28%29

guava：LoadingCache。

发表评论取消回复

还没有评论，来说两句吧...

相关阅读