Guava Cache缓存的使用和介绍

偏执的太偏执、 2022-05-08 16:06 258阅读 0赞

源码地址：[https://github.com/google/guava][https_github.com_google_guava]

API：[https://google.github.io/guava/releases/snapshot-jre/api/docs/][https_google.github.io_guava_releases_snapshot-jre_api_docs]

# #

## 范例 ##

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    
         .maximumSize(1000)
    
         .expireAfterWrite(10, TimeUnit.MINUTES)
    
         .removalListener(MY_LISTENER)
    
         .build(
    
             new CacheLoader<Key, Graph>() {
    
                 public Graph load(Key key) throws AnyException {
    
                     return createExpensiveGraph(key);
    
                 }
    
            });

## 适用性 ##

缓存在很多场景下都是相当有用的。例如，计算或检索一个值的代价很高，并且对同样的输入需要不止一次获取值的时候，就应当考虑使用缓存。

Guava Cache与ConcurrentMap很相似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。在某些场景下，尽管LoadingCache 不回收元素，它也是很有用的，因为它会自动加载缓存。

## 加载 ##

在使用缓存前，首先问自己一个问题：有没有合理的默认方法来加载或计算与键关联的值？如果有的话，你应当使用CacheLoader。如果没有，或者你想要覆盖默认的加载运算，同时保留"获取缓存-如果没有-则计算"\[get-if-absent-compute\]的原子语义，你应该在调用get时传入一个Callable实例。缓存元素也可以通过Cache.put方法直接插入，但自动加载是首选的，因为它可以更容易地推断所有缓存内容的一致性。

### [CacheLoader][] ###

LoadingCache是附带CacheLoader构建而成的缓存实现。创建自己的CacheLoader通常只需要简单地实现V load(K key) throws Exception方法。例如，你可以用下面的代码构建LoadingCache：

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    
          .maximumSize(1000)
    
          .build(
    
              new CacheLoader<Key, Graph>() {
    
                  public Graph load(Key key) throws AnyException {
    
                      return createExpensiveGraph(key);
    
                  }
    
              });
    
    ...
    
    try {
        return graphs.get(key);
    } catch (ExecutionException e) {
        throw new OtherException(e.getCause());
    }

从LoadingCache查询的正规方式是使用[get(K)][get_K]方法。这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值。由于CacheLoader可能抛出异常，LoadingCache.get(K)也声明为抛出ExecutionException异常。如果你定义的CacheLoader没有声明任何检查型异常，则可以通过getUnchecked(K)查找缓存；但必须注意，一旦CacheLoader声明了检查型异常，就不可以调用getUnchecked(K)。

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    
         .expireAfterAccess(10, TimeUnit.MINUTES)
    
         .build(
    
             new CacheLoader<Key, Graph>() {
    
                 public Graph load(Key key) { // no checked exception
    
                     return createExpensiveGraph(key);
    
                 }
    
             });
    
    
    
    ...
    return graphs.getUnchecked(key);

getAll(Iterable<? extends K>)方法用来执行批量查询。默认情况下，对每个不在缓存中的键，getAll方法会单独调用CacheLoader.load来加载缓存项。如果批量的加载比多个单独加载更高效，你可以重载[CacheLoader.loadAll][]来利用这一点。getAll(Iterable)的性能也会相应提升。

*注：CacheLoader.loadAll的实现可以为没有明确请求的键加载缓存值。例如，为某组中的任意键计算值时，能够获取该组中的所有键值，loadAll方法就可以实现为在同一时间获取该组的其他键值*。*校注：getAll(Iterable<? extends K>)方法会调用loadAll，但会筛选结果，只会返回请求的键值对。*

### [Callable][] ###

所有类型的Guava Cache，不管有没有自动加载功能，都支持[get(K, Callable<V>)][get_K_ Callable_V]方法。这个方法返回缓存中相应的值，或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回；否则运算、缓存、然后返回"。

Cache<Key, Graph> cache = CacheBuilder.newBuilder()
    
            .maximumSize(1000)
    
            .build(); // look Ma, no CacheLoader
    
    ...
    
    try {
    
        // If the key wasn't in the "easy to compute" group, we need to
    
        // do things the hard way.
    
        cache.get(key, new Callable<Key, Graph>() {
    
            @Override
    
            public Value call() throws AnyException {
    
                return doThingsTheHardWay(key);
    
            }
    
        });
    
    } catch (ExecutionException e) {
    
        throw new OtherException(e.getCause());
    
    }

### 显式插入 ###

使用[cache.put(key, value)][cache.put_key_ value]方法可以直接向缓存中插入值，这会直接覆盖掉给定键之前映射的值。使用Cache.asMap()视图提供的任何方法也能修改缓存。但请注意，asMap视图的任何方法都不能保证缓存项被原子地加载到缓存中。进一步说，asMap视图的原子运算在Guava Cache的原子加载范畴之外，所以相比于Cache.asMap().putIfAbsent(K,  
V)，Cache.get(K, Callable<V>) 应该总是优先使用。

## 缓存回收 ##

一个残酷的现实是，我们几乎一定没有足够的内存缓存所有数据。你你必须决定：什么时候某个缓存项就不值得保留了？Guava Cache提供了三种基本的缓存回收方式：基于容量回收、定时回收和基于引用回收。

### 基于容量的回收（size-based eviction） ###

如果要规定缓存项的数目不超过固定值，只需使用[CacheBuilder.maximumSize(long)][CacheBuilder.maximumSize_long]。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。——*警告*：在缓存项的数目达到限定值之前，缓存就可能进行回收操作——通常来说，这种情况发生在缓存项的数目逼近限定值时。

另外，不同的缓存项有不同的“权重”（weights）——例如，如果你的缓存值，占据完全不同的内存空间，你可以使用[CacheBuilder.weigher(Weigher)][CacheBuilder.weigher_Weigher]指定一个权重函数，并且用[CacheBuilder.maximumWeight(long)][CacheBuilder.maximumWeight_long]指定最大总重。在权重限定场景中，除了要注意回收也是在重量逼近限定值时就进行了，还要知道重量是在缓存创建时计算的，因此要考虑重量计算的复杂度。

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    
          .maximumWeight(100000)
    
          .weigher(new Weigher<Key, Graph>() {
    
              public int weigh(Key k, Graph g) {
    
                  return g.vertices().size();
    
              }
    
          })
    
          .build(
    
              new CacheLoader<Key, Graph>() {
    
                  public Graph load(Key key) { // no checked exception
    
                      return createExpensiveGraph(key);
    
                  }
    
                });

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

CacheBuilder提供两种定时回收的方法：

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

如下文所讨论，定时回收周期性地在写操作中执行，偶尔在读操作中执行。

测试定时回收

对定时回收进行测试时，不一定非得花费两秒钟去测试两秒的过期。你可以使用[Ticker][]接口和[CacheBuilder.ticker(Ticker)][CacheBuilder.ticker_Ticker]方法在缓存中自定义一个时间源，而不是非得用系统时钟。

### 基于引用的回收（Reference-based Eviction） ###

通过使用弱引用的键、或弱引用的值、或软引用的值，Guava Cache可以把缓存设置为允许垃圾回收：

*  [CacheBuilder.weakKeys()][CacheBuilder.weakKeys]：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用键的缓存用==而不是equals比较键。
 *  [CacheBuilder.weakValues()][CacheBuilder.weakValues]：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用值的缓存用==而不是equals比较值。
 *  [CacheBuilder.softValues()][CacheBuilder.softValues]：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（见上文，基于容量回收）。使用软引用值的缓存同样用==而不是equals比较值。

### 显式清除 ###

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

*  个别清除：[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抛出的任何异常都会在记录到日志后被丢弃\[swallowed\]。

CacheLoader<Key, DatabaseConnection> loader = new CacheLoader<Key, DatabaseConnection> () {
        public DatabaseConnection load(Key key) throws Exception {
            return openConnection(key);
        }
    };
    
    RemovalListener<Key, DatabaseConnection> removalListener = new RemovalListener<Key, DatabaseConnection>() {
        public void onRemoval(RemovalNotification<Key, DatabaseConnection> removal) {
            DatabaseConnection conn = removal.getValue();
            conn.close(); // tear down properly
        }
    };
    
    
    return CacheBuilder.newBuilder()
      .expireAfterWrite(2, TimeUnit.MINUTES)
      .removalListener(removalListener)
      .build(loader);

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

### 清理什么时候发生？ ###

使用CacheBuilder构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。相反，它会在写操作时顺带做少量的维护工作，或者偶尔在读操作时做——如果写操作实在太少的话。

这样做的原因在于：如果要自动地持续清理缓存，就必须有一个线程，这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样CacheBuilder就不可用了。

相反，我们把选择权交到你手里。如果你的缓存是高吞吐的，那就无需担心缓存的维护和清理等工作。如果你的 缓存只会偶尔有写操作，而你又不想清理工作阻碍了读操作，那么可以创建自己的维护线程，以固定的时间间隔调用[Cache.cleanUp()][Cache.cleanUp]。[ScheduledExecutorService][]可以帮助你很好地实现这样的定时调度。

### 刷新 ###

刷新和回收不太一样。正如[LoadingCache.refresh(K)][LoadingCache.refresh_K]所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。

如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃\[swallowed\]。

重载[CacheLoader.reload(K, V)][CacheLoader.reload_K_ V]可以扩展刷新时的行为，这个方法允许开发者在计算新值时使用旧的值。

//有些键不需要刷新，并且我们希望刷新是异步完成的
    LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    
        .maximumSize(1000)
    
        .refreshAfterWrite(1, TimeUnit.MINUTES)
    
        .build(
    
            new CacheLoader<Key, Graph>() {
    
                public Graph load(Key key) { // no checked exception
    
                    return getGraphFromDatabase(key);
    
                }
    
    
    
                public ListenableFuture<Key, Graph> reload(final Key key, Graph prevGraph) {
    
                    if (neverNeedsRefresh(key)) {
    
                        return Futures.immediateFuture(prevGraph);
    
                    }else{
    
                        // asynchronous!
    
                        ListenableFutureTask<Key, Graph> task=ListenableFutureTask.create(new Callable<Key, Graph>() {
    
                            public Graph call() {
    
                                return getGraphFromDatabase(key);
    
                            }
    
                        });
    
                        executor.execute(task);
    
                        return task;
    
                    }
    
                }
    
                });

[CacheBuilder.refreshAfterWrite(long, TimeUnit)][CacheBuilder.refreshAfterWrite_long_ TimeUnit]可以为缓存增加自动定时刷新功能。和expireAfterWrite相反，refreshAfterWrite通过定时刷新可以让缓存项保持可用，但请注意：缓存项只有在被检索时才会真正刷新（如果CacheLoader.refresh实现为异步，那么检索不会被刷新拖慢）。因此，如果你在缓存上同时声明expireAfterWrite和refreshAfterWrite，缓存并不会因为刷新盲目地定时重置，如果缓存项没有被检索，那刷新就不会真的发生，缓存项在过期时间后也变得可以回收。

[https_github.com_google_guava]: https://github.com/google/guava
[https_google.github.io_guava_releases_snapshot-jre_api_docs]: https://google.github.io/guava/releases/snapshot-jre/api/docs/
[CacheLoader]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheLoader.html
[get_K]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/LoadingCache.html#get%28K%29
[CacheLoader.loadAll]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheLoader.html#loadAll%28java.lang.Iterable%29
[Callable]: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Callable.html
[get_K_ Callable_V]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#get%28java.lang.Object,java.util.concurrent.Callable%29
[cache.put_key_ value]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#put%28K,%20V%29
[CacheBuilder.maximumSize_long]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#maximumSize%28long%29
[CacheBuilder.weigher_Weigher]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#weigher%28com.google.common.cache.Weigher%29
[CacheBuilder.maximumWeight_long]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#maximumWeight%28long%29
[expireAfterAccess_long_ TimeUnit]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#expireAfterAccess%28long,%20java.util.concurrent.TimeUnit%29
[expireAfterWrite_long_ TimeUnit]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#expireAfterWrite%28long,%20java.util.concurrent.TimeUnit%29
[Ticker]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/base/Ticker.html
[CacheBuilder.ticker_Ticker]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#ticker%28com.google.common.base.Ticker%29
[CacheBuilder.weakKeys]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheBuilder.html#weakKeys%28%29
[CacheBuilder.weakValues]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheBuilder.html#weakValues%28%29
[CacheBuilder.softValues]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheBuilder.html#softValues%28%29
[Cache.invalidate_key]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#invalidate%28java.lang.Object%29
[Cache.invalidateAll_keys]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#invalidateAll%28java.lang.Iterable%29
[Cache.invalidateAll]: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/Cache.html#invalidateAll%28%29
[CacheBuilder.removalListener_RemovalListener]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#removalListener%28com.google.common.cache.RemovalListener%29
[RemovalListener]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalListener.html
[RemovalNotification]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalNotification.html
[RemovalCause]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/RemovalCause.html
[RemovalListeners.asynchronous_RemovalListener_ Executor]: 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
[Cache.cleanUp]: http://docs.guava-libraries.googlecode.com/git-history/v11.0.1/javadoc/com/google/common/cache/Cache.html#cleanUp%28%29
[ScheduledExecutorService]: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ScheduledExecutorService.html
[LoadingCache.refresh_K]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/LoadingCache.html#refresh%28K%29
[CacheLoader.reload_K_ V]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheLoader.html#reload%28K,%20V%29
[CacheBuilder.refreshAfterWrite_long_ TimeUnit]: http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/cache/CacheBuilder.html#refreshAfterWrite%28long,%20java.util.concurrent.TimeUnit%29