Java 类库中的瑞士军刀:Google Guava 缓存

Java 类库中的瑞士军刀:Google Guava 缓存

Google Guava 被誉为是JAVA类库中的瑞士军刀。能显著简化代码,让代码易写、易读、易于维护。同时可以大幅提高程序员的工作效率,让我们从大量重复的底层代码中脱身。

由于 Google Guava 类库包含大量非常有用的特性,无法在一篇文章中尽述。本篇仅简单介绍 Google Guava 中的缓存工具的使用。

依赖

使用 Maven 进行项目构建时,添加下面的依赖:

<dependency> 
 
<groupId>com.google.guava</groupId> 
 
<artifactId>guava</artifactId> 
 
<version>29.0-jre</version> 
 
<!-- or, for Android: --> 
 
<version>29.0-android</version> 
 
</dependency> 

使用 Gradle 进行项目构建时,添加下面的依赖:

dependencies { 
 
// Pick one: 
 
// 1. Use Guava in your implementation only: 
 
implementation("com.google.guava:guava:29.0-jre") 
 
// 2. Use Guava types in your public API: 
 
api("com.google.guava:guava:29.0-jre") 
 
// 3. Android - Use Guava in your implementation only: 
 
implementation("com.google.guava:guava:29.0-android") 
 
// 4. Android - Use Guava types in your public API: 
 
api("com.google.guava:guava:29.0-android") 
 
} 

示例

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

适用性

缓存有非常广泛的应用场景。比如,你应该为那些计算或者查询代价高昂的数据使用缓存,或者你需要某个输入数据很多次的场景。

一个 `Cache` 类似于 `ConcurrentMap`,不过并不完全相同。基本的差异在于, `ConcurrentMap` 持久化所有添加进来的元素直到它们被显式删除。另一方面,通常将 `Cache` 配置为自动淘汰条目,以限制其内存占用量。在某些情况下, `LoadingCache` 会很有用,虽然它不淘汰条目,但是可以自动加载缓存。

通常,Guava 缓存工具可以适用于下列场景:

  • 希望使用一些内存空间来改善速度。
  • 您希望多次查询某些键。
  • 您的缓存将不需要存储超出 RAM 容量的数据。(Guava 缓存的作用范围局限于在应用程序的一次运行中。它们不将数据存储在文件中或外部服务器上。如果这不符合您的需求,请考虑使 Memcached)

如果这些都适用于您的应用场景,那么 Guava 缓存实用程序将很适合您!

如上面的示例代码所示,使用 `CacheBuilder` 生成器模式可以获取 `Cache`,但是自定义缓存是有趣的部分。

注意:如果不需要 `Cache` 的功能,则 `ConcurrentHashMap` 的内存使用效率更高——但是很难用任何旧的 `ConcurrentMap`来复制大多数 `Cache` 的功能。

填充

你需要问自己有关缓存的第一个问题是:是否有一些合理的默认函数来加载或计算与键关联的值?如果是这样,您应该使用 `CacheLoader`。如果不是这样,或者如果您需要覆盖默认值,但是仍然需要原子的 "get-if-absent-compute" 语义,则应该将 `Callable` 传递给 `get` 调用。可以使用 `Cache.put` 直接插入元素,但是首选自动加载缓存,因为这样可以更轻松地推断所有缓存内容的一致性

使用 CacheLoader

`LoadingCache` 是一个通过附属的 `CacheLoader` 构建的 `Cache`。创建一个 `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)` 方法。这将返回一个已经缓存的值,或者使用缓存的 `CacheLoader` 原子地将新值加载到缓存中。由于 `CacheLoader` 可能会抛出 `Exception`,因此 `LoadingCache.get(K)` 会抛出 `ExecutionException`。(如果缓存加载器抛出 unchecked 异常,则`get(K)` 会引发包装了 `UncheckedExecutionException` 的异常。)您还可以选择使用 `getUnchecked(K)` 将所有异常包装在 `UncheckedExecutionException` 中, 但是如果底层的 `CacheLoader` 通常会抛出受检查异常,这可能会导致令人惊讶的行为。

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` 可能会同时加载其余组。

使用 Callable

所有 Guava 缓存(无论是否加载)均支持方法 `get(K, Callable)`。此方法返回与缓存中的键关联的值,或从指定的 `Callable` 中计算出该值并将其添加到缓存中。在加载完成之前,不会修改与此缓存关联的可观察状态。此方法为常规的“如果已缓存,则返回;否则创建,缓存并返回”模式提供了简单的替代方法。

Cache<Key, Value> 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<Value>() { 
 
@Override 
 
public Value call() throws AnyException { 
 
return doThingsTheHardWay(key); 
 
} 
 
}); 
 
} catch (ExecutionException e) { 
 
throw new OtherException(e.getCause()); 
 
} 

直接插入

可以直接使用 `cache.put(key, value)` 。这将覆盖高速缓存中指定键的任何先前条目。也可以使用 `Cache.asMap()` 视图公开的任何 `ConcurrentMap` 方法对缓存进行更改。注意,`asMap` 视图上的任何方法都不会导致条目自动加载到缓存中。此外,该视图上的原子操作在自动缓存加载范围之外运行,因此在使用 `CacheLoader` 或 `Callable` 加载值的缓存中,始终应优先选择 `Cache.get(K, Callable<V>)` 而不是 `Cache.asMap().putIfAbsent` 。

驱逐

冷酷的现实是,我们几乎肯定没有足够的内存来缓存我们可以缓存的所有内容。您必须决定:什么时候不值得保留缓存条目?Guava 提供三种基本的驱逐类型:基于大小的驱逐,基于时间的驱逐和基于引用的驱逐。

基于大小的驱逐

如果你的缓存在达到某个大小之后就不应该继续增长,可以使用 `CacheBuilder.maximumSize(long)`。缓存将会尝试驱逐最近最少使用的缓存数据实体。

警告:缓存可能会在大小达到限制之前驱逐实体——通常是在缓存大小接近限制时。

另外,如果不同的缓存实体具有不同的“权重”——比如,如果你的缓存值具有不同的内存空间占用——你可以使用 `CacheBuilder.weigher(Weigher)` 指定权重函数,同时使用 `CacheBuilder.maximumWeight(long)` 指定最大缓存权重。除了需要与 `maximumSize` 相同的限制外,请注意,权重是在条目创建时计算的,此后是静态的。

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); 
 
} 
 
}); 

基于时间的驱逐

  • `CacheBuilder` 提供了两种基于时间的驱逐方法:
  • `expireAfterAccess(long, TimeUnit)` 仅在自从上次通过读取或写入访问条目以来经过指定的持续时间后,条目才到期。请注意,驱逐条目的顺序将类似于基于大小的驱逐。
  • `expireAfterWrite(long, TimeUnit)` 自创建条目以来经过指定的时间或该值的最新替换之后,使条目过期。如果经过一定时间后缓存的数据持续增长,则可能需要这样做。

定时到期是在写入过程中进行定期维护的,偶尔在读取过程中进行维护,如下所述。

基于引用的驱逐

Guava 允许你设置你的缓存以允许数据实体的垃圾收集,通过对键或者值使用的 weak references ,或者对值使用的 soft references 进行设置。

  • `CacheBuilder.weakKeys()` 使用弱引用存储键。这允许实体在没有其他引用(强引用或者软引用)指向其键时被垃圾收集。由于垃圾收集基于 id 相等规则,这就导致整个缓存多需要使用 id (`==`)相等来比较键,而不是使用 `equals()`。
  • `CacheBuilder.weakValues()` 使用弱引用存储值。这允许实体在没有其他引用(强引用或者软引用)指向其值时被垃圾收集。由于垃圾收集基于 id 相等规则,这就导致整个缓存多需要使用 id (`==`)相等来比较值,而不是使用 `equals()`。
  • `CacheBuilder.softValues()` 将值包装进入软引用。软引用对象以全局最近最少使用规则进行垃圾收集,以响应内存需求。由于使用软引用可能会有些性能问题,我们通常推荐使用更加容易预测的 maximum cache size 替代。使用 `softValues()` 将导致值被通过 id (`==`) 相等比较,而不是使用 `equals()`。

显式删除

任何时刻,你都可以显式废除缓存实体,而不需要等待实体被驱逐。可以通过以下方法:

  • 单个废除,使用 `Cache.invalidate(key)`
  • 批量废除,使用 `Cache.invalidateAll(keys)`
  • 全部废除,使用 `Cache.invalidateAll()`

清理何时发生?

用 `CacheBuilder` 构建的缓存不会“自动”或在值过期后立即执行清除和逐出值,或类似的任何操作。取而代之的是,它在写操作期间或偶尔进行的读操作(如果很少进行写操作)中执行少量维护。

这样做的原因如下:如果我们要连续执行 `Cache` 维护,则需要创建一个线程,并且该线程的操作将与用户操作竞争共享。另外,某些环境限制了线程的创建,这会使 `CacheBuilder` 在该环境中无法使用。

相反,我们会将选择权交给您。如果您的缓存是高吞吐量的,那么您不必担心执行缓存维护以清理过期的条目等。 如果您的缓存确实很少写入,并且您不想清理来阻止缓存读取,则您可能希望创建自己的维护线程,该线程定期调用 `Cache.cleanUp()`。

如果要为很少写入的缓存安排定期的缓存维护,只需使用 `ScheduledExecutorService` 调度维护操作。

刷新

刷新与驱逐并不完全相同。如 `LoadingCache.refresh(K)` 所述,刷新键可能会异步加载该键的新值。与驱逐相反,旧键(如果有的话)在刷新键时仍会返回,这迫使检索要等到重新加载该值。

如果刷新时引发异常,则将保留旧值,并记录并吞下该异常。

`CacheLoader` 可以通过覆盖 `CacheLoader.reload(K, V)` 指定某些将要在刷新时执行的明智行为,它允许您在计算新值时使用旧值。

// Some keys don't need refreshing, and we want refreshes to be done asynchronously. 
 
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<Graph> reload(final Key key, Graph prevGraph) { 
 
if (neverNeedsRefresh(key)) { 
 
return Futures.immediateFuture(prevGraph); 
 
} else { 
 
// asynchronous! 
 
ListenableFutureTask<Graph> task = ListenableFutureTask.create(new Callable<Graph>() { 
 
public Graph call() { 
 
return getGraphFromDatabase(key); 
 
} 
 
}); 
 
executor.execute(task); 
 
return task; 
 
} 
 
} 
 
}); 

可以使用 `CacheBuilder.refreshAfterWrite(long, TimeUnit)` 将自动定时刷新添加到缓存中。与 `expireAfterWrite` 相比,`refreshAfterWrite` 在指定的持续时间后将使键“具有资格”进行刷新,但实际上仅在查询条目时才会启动刷新。(如果将 `CacheLoader.reload` 实现为异步,则刷新不会降低查询的速度。)因此,例如,您可以在同一缓存上同时指定 `refreshAfterWrite` 和 `expireAfterWrite`,以便只要条目符合刷新资格,就不会盲目地重置条目的过期计时器,因此,如果在符合刷新资格后不查询条目,则允许它过期。

原文 

http://news.51cto.com/art/202007/620090.htm

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Java 类库中的瑞士军刀:Google Guava 缓存

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址