背景
缓存的主要作用是暂时在内存中保存业务系统的数据处理结果,并且等待下次访问使用。在日长开发有很多场合,有一些数据量不是很大,不会经常改动,并且访问非常频繁。但是由于受限于硬盘IO的性能或者远程网络等原因获取可能非常的费时。会导致我们的程序非常缓慢,这在某些业务上是不能忍的!而缓存正是解决这类问题的神器!
当然也并不是说你用了缓存你的系统就一定会变快,建议在用之前看一下使用缓存的9大误区(上) 使用缓存的9大误区(下)
缓存在很多系统和架构中都用广泛的应用,例如:
- CPU缓存
- 操作系统缓存
- HTTP缓存
- 数据库缓存
- 静态文件缓存
- 本地缓存
- 分布式缓存
可以说在计算机和网络领域,缓存是无处不在的。可以这么说,只要有硬件性能不对等,涉及到网络传输的地方都会有缓存的身影。
缓存总体可分为两种 集中式缓存 和 分布式缓存
“集中式缓存"与"分布式缓存"的区别其实就在于“集中”与"非集中"的概念,其对象可能是服务器、内存条、硬盘等。比如:
1.服务器版本:
- 缓存集中在一台服务器上,为集中式缓存。
- 缓存分散在不同的服务器上,为分布式缓存。
2.内存条版本:
- 缓存集中在一台服务器的一条内存条上,为集中式缓存。
- 缓存分散在一台服务器的不同内存条上,为分布式缓存。
3.硬盘版本:
- 缓存集中在一台服务器的一个硬盘上,为集中式缓存。
- 缓存分散在一台服务器的不同硬盘上,为分布式缓存。
想了解分布式缓存可以看一下浅谈分布式缓存那些事儿。
这是几个当前比较流行的`java`分布式缓存框架5个强大的Java分布式缓存框架推荐。
而我们今天要讲的是集中式内存缓存`guava cache`,这是当前我们项目正在用的缓存工具,研究一下感觉还蛮好用的。当然也有很多其他工具,还是看个人喜欢。`oschina`上面也有很多类似开源的java缓存框架
正文
`Guava Cache`与`ConcurrentMap`很相似,但也不完全一样。最基本的区别是`ConcurrentMap`会一直保存所有添加的元素,直到显式地移除。相对地,`Guava Cache`为了限制内存占用,通常都设定为自动回收元素。在某些场景下,尽管`LoadingCache`不回收元素,它也是很有用的,因为它会自动加载缓存。
`Guava Cache`是在内存中缓存数据,相比较于数据库或`redis`存储,访问内存中的数据会更加高效。`Guava`官网介绍,下面的这几种情况可以考虑使用`Guava Cache`:
-
愿意消耗一些内存空间来提升速度。
-
预料到某些键会被多次查询。
-
缓存中存放的数据总量不会超出内存容量。
所以,可以将程序频繁用到的少量数据存储到`Guava Cache`中,以改善程序性能。下面对`Guava Cache`的用法进行详细的介绍。
引用库
<dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>30.1-jre</version> <!-- or, for Android: --> <version>30.1-android</version> </dependency>
构建缓存对象
接口`Cache`代表一块缓存,它有如下方法:
public interface Cache<K, V> { V get(K key, Callable<? extends V> valueLoader) throws ExecutionException; ImmutableMap<K, V> getAllPresent(Iterable<?> keys); void put(K key, V value); void putAll(Map<? extends K, ? extends V> m); void invalidate(Object key); void invalidateAll(Iterable<?> keys); void invalidateAll(); long size(); CacheStats stats(); ConcurrentMap<K, V> asMap(); void cleanUp(); }
可以通过`CacheBuilder`类构建一个缓存对象,`CacheBuilder`类采用`builder`设计模式,它的每个方法都返回`CacheBuilder`本身,直到`build`方法被调用。构建一个缓存对象代码如下。
public class StudyGuavaCache { public static void main(String[] args) { Cache<String,String> cache = CacheBuilder.newBuilder().build(); cache.put("word","Hello Guava Cache"); System.out.println(cache.getIfPresent("word")); } }
上面的代码通过CacheBuilder.newBuilder().build()这句代码创建了一个`Cache`缓存对象,并在缓存对象中存储了key为word,value为`Hello Guava Cache`的一条记录。可以看到`Cache`非常类似于`JDK`中的`Map`,但是相比于`Map`,`Guava Cache`提供了很多更强大的功能。
从`LoadingCache`查询的正规方式是使用`get(K)`方法。这个方法要么返回已经缓存的值,要么使用CacheLoader向缓存原子地加载新值(通过`load(String key)`方法加载)。由于`CacheLoader`可能抛出异常,`LoadingCache.get(K)`也声明抛出`ExecutionException`异常。如果你定义的CacheLoader没有声明任何检查型异常,则可以通过`getUnchecked(K)`查找缓存;但必须注意,一旦`CacheLoader`声明了检查型异常,就不可以调用`getUnchecked(K)`。
LoadingCache<Key, Value> cache = CacheBuilder.newBuilder() .build( new CacheLoader<Key, Value>() { public Value load(Key key) throws AnyException { return createValue(key); } }); ... try { return cache.get(key); } catch (ExecutionException e) { throw new OtherException(e.getCause()); }
设置最大存储
Guava Cache可以在构建缓存对象时指定缓存所能够存储的最大记录数量。当Cache中的记录数量达到最大值后再调用put方法向其中添加对象,Guava会先从当前缓存的对象记录中选择一条删除掉,腾出空间后再将新的对象存储到Cache中。
public class StudyGuavaCache { public static void main(String[] args) { Cache<String,String> cache = CacheBuilder.newBuilder() .maximumSize(2) .build(); cache.put("key1","value1"); cache.put("key2","value2"); cache.put("key3","value3"); System.out.println("第一个值:" + cache.getIfPresent("key1")); System.out.println("第二个值:" + cache.getIfPresent("key2")); System.out.println("第三个值:" + cache.getIfPresent("key3")); } }
上面代码在构造缓存对象时,通过`CacheBuilder`类的`maximumSize`方法指定`Cache`最多可以存储两个对象,然后调用`Cache`的`put`方法向其中添加了三个对象。程序执行结果如下图所示,可以看到第三条对象记录的插入,导致了第一条对象记录被删除。
设置过期时间
在构建`Cache`对象时,可以通过`CacheBuilder`类的`expireAfterAccess`和`expireAfterWrite`两个方法为缓存中的对象指定过期时间,使用`CacheBuilder`构建的缓存不会“自动”执行清理和逐出值,也不会在值到期后立即执行或逐出任何类型。相反,它在写入操作期间执行少量维护,或者在写入很少的情况下偶尔执行读取操作。其中,`expireAfterWrite`方法指定对象被写入到缓存后多久过期,`expireAfterAccess`指定对象多久没有被访问后过期。
public class StudyGuavaCache { public static void main(String[] args) throws InterruptedException { Cache<String,String> cache = CacheBuilder.newBuilder() .maximumSize(2) .expireAfterWrite(3,TimeUnit.SECONDS) .build(); cache.put("key1","value1"); int time = 1; while(true) { System.out.println("第" + time++ + "次取到key1的值为:" + cache.getIfPresent("key1")); Thread.sleep(1000); } } }
上面的代码在构造`Cache`对象时,通过`CacheBuilder`的`expireAfterWrite`方法指定`put`到`Cache`中的对象在3秒后会过期。在Cache对象中存储一条对象记录后,每隔1秒读取一次这条记录。程序运行结果如下图所示,可以看到,前三秒可以从`Cache`中获取到对象,超过三秒后,对象从`Cache`中被自动删除。
下面代码是expireAfterAccess的例子。
public class StudyGuavaCache { public static void main(String[] args) throws InterruptedException { Cache<String,String> cache = CacheBuilder.newBuilder() .maximumSize(2) .expireAfterAccess(3,TimeUnit.SECONDS) .build(); cache.put("key1","value1"); int time = 1; while(true) { Thread.sleep(time*1000); System.out.println("睡眠" + time++ + "秒后取到key1的值为:" + cache.getIfPresent("key1")); } } }
通过`CacheBuilder`的`expireAfterAccess`方法指定`Cache`中存储的对象如果超过3秒没有被访问就会过期。`while`中的代码每`sleep`一段时间就会访问一次`Cache`中存储的对象`key1`,每次访问`key1`之后下次`sleep`的时间会加长一秒。程序运行结果如下图所示,从结果中可以看出,当超过3秒没有读取`key1`对象之后,该对象会自动被`Cache`删除。
也可以同时用`expireAfterAccess`和`expireAfterWrite`方法指定过期时间,这时只要对象满足两者中的一个条件就会被自动过期删除。
`Guava Cache`缓存过期后不一定会立马被清理,一般会在`Cache`整体被读取一定次数后清理。这种策略对性能是有好处的,如果想强制清理可以手动调用`Cache.cleanup()`或者使用`ScheduledExecutorService`来完成定期清理。
弱引用
可以通过`weakKeys`和`weakValues`方法指定`Cache`只保存对缓存记录`key`和`value`的弱引用。这样当没有其他强引用指向`key`和`value`时,`key`和`value`对象就会被垃圾回收器回收。
public class StudyGuavaCache { public static void main(String[] args) throws InterruptedException { Cache<String,Object> cache = CacheBuilder.newBuilder() .maximumSize(2) .weakValues() .build(); Object value = new Object(); cache.put("key1",value); value = new Object();//原对象不再有强引用 System.gc(); System.out.println(cache.getIfPresent("key1")); } }
上面代码的打印结果是null。构建Cache时通过weakValues方法指定Cache只保存记录值的一个弱引用。当给value引用赋值一个新的对象之后,就不再有任何一个强引用指向原对象。System.gc()触发垃圾回收后,原对象就被清除了。
显式清除
可以调用Cache的invalidateAll或invalidate方法显示删除Cache中的记录。invalidate方法一次只能删除Cache中一个记录,接收的参数是要删除记录的key。invalidateAll方法可以批量删除Cache中的记录,当没有传任何参数时,invalidateAll方法将清除Cache中的全部记录。invalidateAll也可以接收一个Iterable类型的参数,参数中包含要删除记录的所有key值。下面代码对此做了示例。
public class StudyGuavaCache { public static void main(String[] args) throws InterruptedException { Cache<String,String> cache = CacheBuilder.newBuilder().build(); Object value = new Object(); cache.put("key1","value1"); cache.put("key2","value2"); cache.put("key3","value3"); List<String> list = new ArrayList<String>(); list.add("key1"); list.add("key2"); cache.invalidateAll(list);//批量清除list中全部key对应的记录 System.out.println(cache.getIfPresent("key1")); System.out.println(cache.getIfPresent("key2")); System.out.println(cache.getIfPresent("key3")); } }
代码中构造了一个集合list用于保存要删除记录的key值,然后调用invalidateAll方法批量删除key1和key2对应的记录,只剩下key3对应的记录没有被删除。
移除监听器
可以为Cache对象添加一个移除监听器,这样当有记录被删除时可以感知到这个事件。
public class StudyGuavaCache { public static void main(String[] args) throws InterruptedException { RemovalListener<String, String> listener = new RemovalListener<String, String>() { public void onRemoval(RemovalNotification<String, String> notification) { System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!"); } }; Cache<String,String> cache = CacheBuilder.newBuilder() .maximumSize(3) .removalListener(listener) .build(); Object value = new Object(); cache.put("key1","value1"); cache.put("key2","value2"); cache.put("key3","value3"); cache.put("key4","value3"); cache.put("key5","value3"); cache.put("key6","value3"); cache.put("key7","value3"); cache.put("key8","value3"); } }
removalListener方法为Cache指定了一个移除监听器,这样当有记录从Cache中被删除时,监听器listener就会感知到这个事件。程序运行结果如下图所示。
自动加载
Cache的get方法有两个参数,第一个参数是要从Cache中获取记录的key,第二个记录是一个Callable对象。当缓存中已经存在key对应的记录时,get方法直接返回key对应的记录。如果缓存中不包含key对应的记录,Guava会启动一个线程执行Callable对象中的call方法,call方法的返回值会作为key对应的值被存储到缓存中,并且被get方法返回。下面是一个多线程的例子:
public class StudyGuavaCache { private static Cache<String,String> cache = CacheBuilder.newBuilder() .maximumSize(3) .build(); public static void main(String[] args) throws InterruptedException { new Thread(new Runnable() { public void run() { System.out.println("thread1"); try { String value = cache.get("key", new Callable<String>() { public String call() throws Exception { System.out.println("load1"); //加载数据线程执行标志 Thread.sleep(1000); //模拟加载时间 return "auto load by Callable"; } }); System.out.println("thread1 " + value); } catch (ExecutionException e) { e.printStackTrace(); } } }).start(); new Thread(new Runnable() { public void run() { System.out.println("thread2"); try { String value = cache.get("key", new Callable<String>() { public String call() throws Exception { System.out.println("load2"); //加载数据线程执行标志 Thread.sleep(1000); //模拟加载时间 return "auto load by Callable"; } }); System.out.println("thread2 " + value); } catch (ExecutionException e) { e.printStackTrace(); } } }).start(); } }
这段代码中有两个线程共享同一个`Cache`对象,两个线程同时调用`get`方法获取同一个`key`对应的记录。由于`key`对应的记录不存在,所以两个线程都在`get`方法处阻塞。此处在`call`方法中调用`Thread.sleep(1000)`模拟程序从外存加载数据的时间消耗。代码的执行结果如下图:
从结果中可以看出,虽然是两个线程同时调用get方法,但只有一个`get`方法中的`Callable`会被执行(没有打印出`load2`)。`Guava`可以保证当有多个线程同时访问`Cache`中的一个`key`时,如果`key`对应的记录不存在,`Guava`只会启动一个线程执行`get`方法中`Callable`参数对应的任务加载数据存到缓存。当加载完数据后,任何线程中的`get`方法都会获取到`key`对应的值。
统计信息
可以对`Cache`的命中率、加载数据时间等信息进行统计。在构建`Cache`对象时,可以通过`CacheBuilder`的`recordStats`方法开启统计信息的开关。开关开启后`Cache`会自动对缓存的各种操作进行统计,调用`Cache`的`stats`方法可以查看统计后的信息。
public class StudyGuavaCache { public static void main(String[] args) throws InterruptedException { Cache<String,String> cache = CacheBuilder.newBuilder() .maximumSize(3) .recordStats() //开启统计信息开关 .build(); cache.put("key1","value1"); cache.put("key2","value2"); cache.put("key3","value3"); cache.put("key4","value4"); cache.getIfPresent("key1"); cache.getIfPresent("key2"); cache.getIfPresent("key3"); cache.getIfPresent("key4"); cache.getIfPresent("key5"); cache.getIfPresent("key6"); System.out.println(cache.stats()); //获取统计信息 } }
程序执行结果如下图所示:
这些统计信息对于调整缓存设置是至关重要的,在性能要求高的应用中应该密切关注这些数据
LoadingCache
LoadingCache是Cache的子接口,相比较于Cache,当从LoadingCache中读取一个指定key的记录时,如果该记录不存在,则LoadingCache可以自动执行加载数据到缓存的操作。LoadingCache接口的定义如下:
public interface LoadingCache<K, V> extends Cache<K, V>, Function<K, V> { V get(K key) throws ExecutionException; V getUnchecked(K key); ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException; V apply(K key); void refresh(K key); @Override ConcurrentMap<K, V> asMap(); }
与构建Cache类型的对象类似,LoadingCache类型的对象也是通过CacheBuilder进行构建,不同的是,在调用CacheBuilder的build方法时,必须传递一个CacheLoader类型的参数,CacheLoader的load方法需要我们提供实现。当调用LoadingCache的get方法时,如果缓存不存在对应key的记录,则CacheLoader中的load方法会被自动调用从外存加载数据,load方法的返回值会作为key对应的value存储到LoadingCache中,并从get方法返回。
public class StudyGuavaCache { public static void main(String[] args) throws ExecutionException { CacheLoader<String, String> loader = new CacheLoader<String, String> () { public String load(String key) throws Exception { Thread.sleep(1000); //休眠1s,模拟加载数据 System.out.println(key + " is loaded from a cacheLoader!"); return key + "'s value"; } }; LoadingCache<String,String> loadingCache = CacheBuilder.newBuilder() .maximumSize(3) .build(loader);//在构建时指定自动加载器 loadingCache.get("key1"); loadingCache.get("key2"); loadingCache.get("key3"); } }
程序执行结果如下图所示:
定时刷新
当某个缓存值过期时,老是会导致大量的请求线程被阻塞。而Guava则提供了另一种缓存策略,缓存值定时刷新:更新线程调用load方法更新该缓存,其他请求线程返回该缓存的旧值。这样对于某个key的缓存来说,只会有一个线程被阻塞,用来生成缓存值,而其他的线程都返回旧的缓存值,不会被阻塞。
这里就需要用到Guava cache的refreshAfterWrite方法。如下所示:
LoadingCache<String, Object> caches = CacheBuilder.newBuilder() .maximumSize(100) .refreshAfterWrite(10, TimeUnit.MINUTES) .build(new CacheLoader<String, Object>() { @Override public Object load(String key) throws Exception { return generateValueByKey(key); } }); try { System.out.println(caches.get("key-zorro")); } catch (ExecutionException e) { e.printStackTrace(); }
如代码所示,每隔十分钟缓存值则会被刷新。
此外需要注意一个点,这里的定时并不是真正意义上的定时。Guava cache的刷新需要依靠用户请求线程,让该线程去进行load方法的调用,所以如果一直没有用户尝试获取该缓存值,则该缓存也并不会刷新。
异步刷新
上面使用方法,解决了同一个key的缓存过期时会让多个线程阻塞的问题,只会让用来执行刷新缓存操作的一个用户线程会被阻塞。由此可以想到另一个问题,当缓存的key很多时,高并发条件下大量线程同时获取不同key对应的缓存,此时依然会造成大量线程阻塞,并且给数据库带来很大压力。这个问题的解决办法就是将刷新缓存值的任务交给后台线程,所有的用户请求线程均返回旧的缓存值,这样就不会有用户线程被阻塞了。
详细做法如下:
ListeningExecutorService backgroundRefreshPools = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(20)); LoadingCache<String, Object> caches = CacheBuilder.newBuilder() .maximumSize(100) .refreshAfterWrite(10, TimeUnit.MINUTES) .build(new CacheLoader<String, Object>() { @Override public Object load(String key) throws Exception { return generateValueByKey(key); } @Override public ListenableFuture<Object> reload(String key, Object oldValue) throws Exception { return backgroundRefreshPools.submit(new Callable<Object>() { @Override public Object call() throws Exception { return generateValueByKey(key); } }); } }); try { System.out.println(caches.get("key-zorro")); } catch (ExecutionException e) { e.printStackTrace(); }
在上面的代码中,我们新建了一个线程池,用来执行缓存刷新任务。并且重写了CacheLoader的reload方法,在该方法中建立缓存刷新的任务并提交到线程池。
注意此时缓存的刷新依然需要靠用户线程来驱动,只不过和2不同之处在于该用户线程触发刷新操作之后,会立马返回旧的缓存值。
Caffeine
新版本的spring boot已经默认推荐使用`Caffeine`来替代`Guava`进行缓存了,主要改进就是淘汰算法的改进,性能改进,以及多线程安全性。
参考链接
- Java time-based map/cache with expiring keys [closed]
- Class CacheBuilder<K,V>
- 干掉GuavaCache:Caffeine才是本地缓存的王
- Guava Cache内存缓存使用实践-定时异步刷新及简单抽象封装
- Guava Cache用法介绍
- spring boot 看看这个 Guava cache 与 caffeine 看来 Guava cache 不能再用了
- Guava 25.1 发布,Google 的 Java 核心工具库
- google / guava
- Guava Cache expireAfterWrite 与 refreshAfterWrite区别
- Caffeine缓存