Google,Guava本地高效缓存

Guva是google开源的一个公共java库,类似于Apache Commons,它提供了集合,反射,缓存,科学计算,xml,io等一些工具类库。
cache只是其中的一个模块。使用Guva cache能够方便快速的构建本地缓存。

使用Guava构建第一个缓存

首先需要在maven项目中加入guava依赖

  1. <dependency>
  2. <groupId>com.google.guava</groupId>
  3. <artifactId>guava</artifactId>
  4. <version>25.0-jre</version>
  5. </dependency>

使用Guava创建一个缓存

  1. // 通过CacheBuilder构建一个缓存实例
  2. Cache<String, String> cache = CacheBuilder.newBuilder()
  3. .maximumSize(100) // 设置缓存的最大容量
  4. .expireAfterWrite(1, TimeUnit.MINUTES) // 设置缓存在写入一分钟后失效
  5. .concurrencyLevel(10) // 设置并发级别为10
  6. .recordStats() // 开启缓存统计
  7. .build();
  8. // 放入缓存
  9. cache.put("key", "value");
  10. // 获取缓存
  11. String value = cache.getIfPresent("key");

expireAfterWrite 缓存一定时间内直接失效
expireAfterAccess 缓存被访问后,一定时间后失效
getIfPresent 不存在就返回null


代码演示了使用Guava创建了一个基于内存的本地缓存,并指定了一些缓存的参数,如缓存容量、缓存过期时间、并发级别等,随后通过put方法放入一个缓存并使用getIfPresent来获取它。

Cache与LoadingCache

Cache是通过CacheBuilder的build()方法构建,它是Gauva提供的最基本的缓存接口,并且它提供了一些常用的缓存api:

  1. Cache<Object, Object> cache = CacheBuilder.newBuilder().build();
  2. // 放入/覆盖一个缓存
  3. cache.put("k1", "v1");
  4. // 获取一个缓存,如果该缓存不存在则返回一个null值
  5. Object value = cache.getIfPresent("k1");
  6. // 获取缓存,当缓存不存在时,则通Callable进行加载并返回。该操作是原子
  7. Object getValue = cache.get("k1", new Callable<Object>() {
  8. @Override
  9. public Object call() throws Exception {
  10. return null;
  11. }
  12. });

LoadingCache

LoadingCache继承自Cache,在构建LoadingCache时,需要通过CacheBuilder的build(CacheLoader<? super K1, V1> loader)方法构建

  1. CacheBuilder.newBuilder()
  2. .build(new CacheLoader<String, String>() {
  3. @Override
  4. public String load(String key) throws Exception {
  5. // 缓存加载逻辑
  6. ...
  7. }
  8. });

它能够通过CacheLoader自发的加载缓存

  1. LoadingCache<Object, Object> loadingCache = CacheBuilder.newBuilder().build(new CacheLoader<Object, Object>() {
  2. @Override
  3. public Object load(Object key) throws Exception {
  4. return null;
  5. }
  6. });
  7. // 获取缓存,当缓存不存在时,会通过CacheLoader自动加载,该方法会抛出ExecutionException异常
  8. loadingCache.get("k1");
  9. // 以不安全的方式获取缓存,当缓存不存在时,会通过CacheLoader自动加载,该方法不会抛出异常
  10. loadingCache.getUnchecked("k1");

缓存的并发级别

Guava提供了设置并发级别的api,使得缓存支持并发的写入和读取。同ConcurrentHashMap类似Guava cache的并发也是通过分离锁实现。在一般情况下,将并发级别设置为服务器cpu核心数是一个比较不错的选择。

  1. CacheBuilder.newBuilder()
  2. // 设置并发级别为cpu核心数
  3. .concurrencyLevel(Runtime.getRuntime().availableProcessors())
  4. .build();

缓存的初始容量

我们在构建缓存时可以为缓存设置一个合理大小初始容量,由于Guava的缓存使用了分离锁的机制,扩容的代价非常昂贵。所以合理的初始容量能够减少缓存容器的扩容次数。

  1. CacheBuilder.newBuilder()
  2. // 设置初始容量为100
  3. .initialCapacity(100)
  4. .build();

使用基于最大容量的的回收策略时,我们需要设置2个必要参数:

  • maximumWeigh;用于指定最大容量。
  • Weigher;在加载缓存时用于计算缓存容量大小。

这里我们例举一个key和value都是String类型缓存:

  1. CacheBuilder.newBuilder()
  2. .maximumWeight(1024 * 1024 * 1024) // 设置最大容量为 1M
  3. // 设置用来计算缓存容量的Weigher
  4. .weigher(new Weigher<String, String>() {
  5. @Override
  6. public int weigh(String key, String value) {
  7. return key.getBytes().length + value.getBytes().length;
  8. }
  9. }).build();

当缓存的最大数量/容量逼近或超过我们所设置的最大值时,Guava就会使用LRU算法对之前的缓存进行回收。

基于软/弱引用的回收

基于引用的回收策略,是java中独有的。在java中有对象自动回收机制,依据程序员创建对象的方式不同,将对象由强到弱分为强引用、软引用、弱引用、虚引用。对于这几种引用他们有以下区别


强引用

强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。

  1. Object o=new Object(); // 强引用

当内存空间不足,垃圾回收器不会自动回收一个被引用的强引用对象,而是会直接抛出OutOfMemoryError错误,使程序异常终止。

软引用

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

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

使用软引用能防止内存泄露,增强程序的健壮性。但是一定要做好null检测。

弱引用

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

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

虚引用

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

在Guava cache中支持,软/弱引用的缓存回收方式。使用这种方式能够极大的提高内存的利用率,并且不会出现内存溢出的异常。

  1. CacheBuilder.newBuilder()
  2. .weakKeys() // 使用弱引用存储键。当键没有其它(强或软)引用时,该缓存可能会被回收。
  3. .weakValues() // 使用弱引用存储值。当值没有其它(强或软)引用时,该缓存可能会被回收。
  4. .softValues() // 使用软引用存储值。当内存不足并且该值其它强引用引用时,该缓存就会被回收
  5. .build();

通过软/弱引用的回收方式,相当于将缓存回收任务交给了GC,使得缓存的命中率变得十分的不稳定,在非必要的情况下,还是推荐基于数量和容量的回收。

显式回收

在缓存构建完毕后,我们可以通过Cache提供的接口,显式的对缓存进行回收,例如:

  1. // 构建一个缓存
  2. Cache<String, String> cache = CacheBuilder.newBuilder().build();
  3. // 回收key为k1的缓存
  4. cache.invalidate("k1");
  5. // 批量回收key为k1、k2的缓存
  6. List<String> needInvalidateKeys = new ArrayList<>();
  7. needInvalidateKeys.add("k1");
  8. needInvalidateKeys.add("k2");
  9. cache.invalidateAll(needInvalidateKeys);
  10. // 回收所有缓存
  11. cache.invalidateAll();

缓存的过期策略与刷新

Guava也提供了缓存的过期策略和刷新策略。

缓存过期策略

缓存的过期策略分为固定时间和相对时间。

固定时间一般是指写入后多长时间过期,例如我们构建一个写入10分钟后过期的缓存:

  1. CacheBuilder.newBuilder()
  2. .expireAfterWrite(10, TimeUnit.MINUTES) // 写入10分钟后过期
  3. .build();
  4. // java8后可以使用Duration设置
  5. CacheBuilder.newBuilder()
  6. .expireAfterWrite(Duration.ofMinutes(10))
  7. .build();

相对时间一般是相对于访问时间,也就是每次访问后,会重新刷新该缓存的过期时间,这有点类似于servlet中的session过期时间,例如构建一个在10分钟内未访问则过期的缓存:

  1. CacheBuilder.newBuilder()
  2. .expireAfterAccess(10, TimeUnit.MINUTES) //在10分钟内未访问则过期
  3. .build();
  4. // java8后可以使用Duration设置
  5. CacheBuilder.newBuilder()
  6. .expireAfterAccess(Duration.ofMinutes(10))
  7. .build();

缓存刷新

在Guava cache中支持定时刷新和显式刷新两种方式,其中只有LoadingCache能够进行定时刷新。

定时刷新

在进行缓存定时刷新时,我们需要指定缓存的刷新间隔,和一个用来加载缓存的CacheLoader,当达到刷新时间间隔后,下一次获取缓存时,会调用CacheLoader的load方法刷新缓存。例如构建个刷新频率为10分钟的缓存:

  1. CacheBuilder.newBuilder()
  2. // 设置缓存在写入10分钟后,通过CacheLoader的load方法进行刷新
  3. .refreshAfterWrite(10, TimeUnit.SECONDS)
  4. // jdk8以后可以使用 Duration
  5. // .refreshAfterWrite(Duration.ofMinutes(10))
  6. .build(new CacheLoader<String, String>() {
  7. @Override
  8. public String load(String key) throws Exception {
  9. // 缓存加载逻辑
  10. ...
  11. }
  12. });

显式刷新

在缓存构建完毕后,我们可以通过Cache提供的一些借口方法,显式的对缓存进行刷新覆盖,例如:

  1. // 构建一个缓存
  2. Cache<String, String> cache = CacheBuilder.newBuilder().build();
  3. // 使用put进行覆盖刷新
  4. cache.put("k1", "v1");
  5. // 使用Map的put方法进行覆盖刷新
  6. cache.asMap().put("k1", "v1");
  7. // 使用Map的putAll方法进行批量覆盖刷新
  8. Map<String,String> needRefreshs = new HashMap<>();
  9. needRefreshs.put("k1", "v1");
  10. cache.asMap().putAll(needRefreshs);
  11. // 使用ConcurrentMap的replace方法进行覆盖刷新
  12. cache.asMap().replace("k1", "v1");

对于LoadingCache,由于它能够自动的加载缓存,所以在进行刷新时,不需要显式的传入缓存的值:

  1. LoadingCache<String, String> loadingCache = CacheBuilder
  2. .newBuilder()
  3. .build(new CacheLoader<String, String>() {
  4. @Override
  5. public String load(String key) throws Exception {
  6. // 缓存加载逻辑
  7. return null;
  8. }
  9. });
  10. // loadingCache 在进行刷新时无需显式的传入 value
  11. loadingCache.refresh("k1");

原文:https://rumenz.com/rumenbiji/google-guava-java.html

返回笔记列表
入门小站