文章目录
- 一. Guava Cache介绍
- 二、Guava Cache使用
- 1. 构建缓存对象 (CacheBuilder)
- 2. 设置初始化容量和最大存储 (initialCapacity, maximumSize)
- 3. 设置过期时间 (expireAfterAccess, expireAfterWrite)
- 4. 弱软引用 (weakKeys, weakValues, softValues)
- 5. 主动清除缓存 (invalidateAll, invalidate)
- 6. 移除监听器 (RemovalListener)
- 7. 自动加载 (重点)
- 8. 统计信息 (recordStats)
- 9. LoadingCache (重点)
- 10. 并发度 (concurrencyLevel)
- 11. 数据清除权重 (maximumWeight, weigher)
- Guava Cache封装工具类
- 三、 常见缓存数据淘汰算法( FIFO + LRU + LFU)
- 四、Guava Cache原理
一. Guava Cache介绍
Guava Cache是在内存中缓存数据(JVM缓存/本地缓存)，相比较于数据库或redis存储，访问内存中的数据会更加高效。Guava官网介绍，下面的这几种情况可以考虑使用Guava Cache：
对性能有非常高的要求愿意消耗一些内存空间来提升速度预料到某些键会被多次查询 (热点数据)缓存中存放的数据总量不会超出内存容量
所以，可以将程序频繁用到的少量数据存储到Guava Cache中，以改善程序性能。下面对Guava Cache的用法进行详细的介绍。
1. Guava cache 优势 (重点)
缓存过期和淘汰机制- GuavaCache中可以设置
Key的过期时间，包括访问过期和创建过期 - GuavaCache在缓存容量(
maximumSize)达到指定大小时，采用LRU+FIFO的方式，将不常使用的键值从Cache中删除
- GuavaCache中可以设置
并发处理能力- GuavaCache类似CurrentHashMap，是线程安全的。
- 提供了设置并发级别的api (
concurrencyLevel(5))，使得缓存支持并发的写入和读取
采用
分离锁机制，分离锁能够减小锁力度，提升并发能力; 分离锁是分拆锁定，把一个集合看分成若干partition, 每个partiton一把锁。ConcurrentHashMap就是分了16个区域，这16个区域之间是可以并发的。GuavaCache采用Segment做分区。更新锁定在缓存中查询某个key，如果不存在，则查源数据，并回填缓存- GuavaCache可以在
CacheLoader的load方法中加以控制，对同一个key，只让一个请求去读源数据并回填缓存，其他请求阻塞等待。
- 集成数据源 (在缓存中读取不到时,可以去读数据源 并写入到缓存中)
- 在业务中操作缓存，都会
操作缓存和数据源两部分GuavaCache的get可以集成数据源，在从缓存中读取不到时可以从数据源中读取数据并回填缓存
- 在业务中操作缓存，都会
- 监控缓存加载/命中情况
- 统计缓存信息,
recordStats(), 开启统计信息开关, 查看通过cache对象stats方法
- 统计缓存信息,
二、Guava Cache使用
1. 构建缓存对象 (CacheBuilder)
接口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提供了很多更强大的功能。
2. 设置初始化容量和最大存储 (initialCapacity, maximumSize)
Guava Cache可以在 构建缓存对象时 指定缓存所能够存储的最大记录数量。
当Cache中的记录数量达到最大值后再调用put方法向其中添加对象，Guava会先从当前缓存的对象记录中选择一条删除掉，腾出空间后再将新的对象存储到Cache中。
public class StudyGuavaCache {
public static void main(String[] args) {
Cache<String,String> cache = CacheBuilder.newBuilder()
// 指定用于缓存的hash table最低总规模; 可以不设置
.initialCapacity(int initialCapacity)
.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方法向其中添加了三个对象。
程序执行结果如下图所示，可以看到第三条对象记录的插入，导致了第一条对象记录被删除：
第一个值：null
第二个值：value2
第三个值：value3
3. 设置过期时间 (expireAfterAccess, expireAfterWrite)
在构建Cache对象时，可以通过CacheBuilder类的expireAfterAccess和expireAfterWrite两个方法为缓存中的对象指定过期时间，过期的对象将会被缓存自动删除。
- expireAfterWrite 指定对象被写入到缓存后多久过期
- expireAfterAccess 指定对象多久没有被访问后过期。
public class StudyGuavaCache {
public static void main(String[] args) throws Exception {
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中被自动删除。
第1次取到key1的值为：value1
第2次取到key1的值为：value1
第3次取到key1的值为：value1
第4次取到key1的值为：null
第5次取到key1的值为：null
第6次取到key1的值为：null
第7次取到key1的值为：null
第8次取到key1的值为：null
第9次取到key1的值为：null
第10次取到key1的值为：null
第11次取到key1的值为：null
下面代码是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 * 1000L);
System.out.println("睡眠" + time++ + "秒后取到key1的值为：" + cache.getIfPresent("key1"));
}
}
}
通过CacheBuilder的expireAfterAccess方法指定Cache中存储的对象如果超过3秒没有被访问就会过期。
while中的代码每sleep一段时间就会访问一次Cache中存储的对象key1，每次访问key1之后下次sleep的时间会加长一秒。程序运行结果如下图所示，从结果中可以看出，当超过3秒没有读取key1对象之后，该对象会自动被Cache删除。
睡眠1秒后取到key1的值为：value1
睡眠2秒后取到key1的值为：value1
睡眠3秒后取到key1的值为：null
睡眠4秒后取到key1的值为：null
睡眠5秒后取到key1的值为：null
睡眠6秒后取到key1的值为：null
睡眠7秒后取到key1的值为：null
睡眠8秒后取到key1的值为：null
睡眠9秒后取到key1的值为：null
4. 弱软引用 (weakKeys, weakValues, softValues)
-
weakKeys
将缓存中的key设置成weakKey模式。默认情况下，会使用“强关系”来保存key值。当设置为weakKey时，会使用（==）来匹配key值。在使用weakKey的情况下，数据可能会被GC。数据被GC后，可能仍然会被size方法计数，但是对其执行read或write方法已经无效。 -
weakValues
将缓存中的数据设置为weakValues模式。启用weakValue设置时，某些数据会被GC。默认情况下，会使用“强关系”来保存key值。当设置为weakValue时，会使用（==）来匹配value值。数据被GC后，可能仍然会被size方法计数，但是对其执行read或write方法已经无效。 -
softValues
将缓存中的数据设置为softValues模式。使用这个模式时，所有的数据都使用SoftReference类对缓存中的数据进行包裹（就是在SoftReference实例中存储真实的数据）。使用SoftReference包裹的数据，会被全局垃圾回收管理器托管，按照LRU的原则来定期GC数据。数据被GC后，可能仍然会被size方法计数，但是对其执行read或write方法已经无效。
// 当key和缓存元素都不再存在其他强引用的时候驱逐
LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
.weakKeys()
.weakValues()
.build(key -> createExpensiveGraph(key));
// 当进行GC的时候进行驱逐
LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
.softValues()
.build(key -> createExpensiveGraph(key));
可以通过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
上面代码的打印结果是null。构建Cache时通过weakValues方法指定Cache只保存记录值的一个弱引用。当给value引用赋值一个新的对象之后，就不再有任何一个强引用指向原对象。System.gc()触发垃圾回收后，原对象就被清除了。
5. 主动清除缓存 (invalidateAll, invalidate)
可以调用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();
cache.put("key1", "value1");
cache.put("key2", "value2");
cache.put("key3", "value3");
// cache.invalidate("key1"); // 清楚key1这个缓存
List<String> list = Lists.newArrayList("key1", "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对应的记录没有被删除
null
null
value3
6. 移除监听器 (RemovalListener)
可以为Cache对象添加一个移除监听器，这样当有记录(缓存)被删除时可以感知到这个事件。
public class StudyGuavaCache {
public static void main(String[] args) {
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();
// 因为maximumSize为3, 所以cache只能存三个缓存,后面的会覆盖前面的缓存
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就会感知到这个事件。程序运行结果如下图所示：
[key1:value1] is removed!
[key2:value2] is removed!
[key3:value3] is removed!
[key4:value3] is removed!
[key5:value3] is removed!
7. 自动加载 (重点)
Cache的get方法有两个参数，第一个参数是要从Cache中获取缓存的key，第二个参数是一个Callable对象。
- 当缓存中已经存在key对应的记录时，get方法直接返回key对应的记录。
- 如果缓存中
不包含key对应的记录，Guava会启动一个线程执行Callable对象中的call方法，call方法的返回值会作为key对应的值被存储到缓存中，并且被get方法返回。
下面是一个多线程的例子：
public class StudyGuavaCache {
private static final Cache<String, String> cache = CacheBuilder.newBuilder()
.maximumSize(3)
.build();
public static void main(String[] args) {
new Thread(() -> {
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 load1 by Callable";
}
});
System.out.println("thread1 " + value);
} catch (ExecutionException e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
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 load2 by Callable";
}
});
System.out.println("thread2 " + value);
} catch (ExecutionException e) {
e.printStackTrace();
}
}).start();
}
}
这段代码中有两个线程共享同一个Cache对象，两个线程同时调用get方法获取同一个key对应的记录。
由于key对应的记录不存在，所以两个线程都在get方法处阻塞。此处在call方法中调用Thread.sleep(1000)模拟程序从外存加载数据的时间消耗。
代码的执行结果如下图：
thread1
thread2
load1
thread1 auto load1 by Callable
thread2 auto load1 by Callable
从结果中可以看出，虽然是两个线程同时调用get方法，但只有一个get方法中的Callable会被执行(没有打印出load2)。
Guava可以保证当有多个线程同时访问Cache中的一个key时，如果key对应的记录不存在，Guava只会启动一个线程执行get方法中Callable参数对应的任务加载数据存到缓存。当加载完数据后，任何线程中的get方法都会获取到key对应的值。
8. 统计信息 (recordStats)
可以对Cache的命中率、加载数据时间等信息进行统计。在构建Cache对象时，可以通过CacheBuilder的recordStats方法开启统计信息的开关。开关开启后Cache会自动对缓存的各种操作进行统计，调用Cache的stats方法可以查看统计后的信息
public class StudyGuavaCache {
public static void main(String[] args) {
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()); //获取统计信息
}
}
这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中应该密切关注这些数据。
CacheStats{hitCount=3, missCount=3, loadSuccessCount=0, loadExceptionCount=0, totalLoadTime=0, evictionCount=1}
9. 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<>() {
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);//在构建时指定自动加载器
// 如果获取key1的数据为空,则会自动调用上面load方法,并将数据缓存到key1中
loadingCache.get("key1");
loadingCache.get("key2");
loadingCache.get("key3");
}
}
key1 is loaded from a cacheLoader!
key2 is loaded from a cacheLoader!
key3 is loaded from a cacheLoader!
10. 并发度 (concurrencyLevel)
Guava Cache可以通过参数concurrencyLevel(5)设置并发度，即可以同时写缓存的线程数。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
Cache<String,String> cache = CacheBuilder.newBuilder()
.maximumSize(3)
.concurrencyLevel(5)
.build();
cache.put("key1","value1");
cache.getIfPresent("key1");
}
}
11. 数据清除权重 (maximumWeight, weigher)
数据清除权重。在缓存的使用中，这个权重的概率很难理解，简单的说就是：每个参数在进入缓存之前都会使用用户自定义的Weigher对象来运算每条数据的权重值。
在进行数据释放时，会参考数据的权重值和设定的“maximumWeight”来确定哪条数据需要被回收。声明代码如下：
public class StudyGuavaCache {
public static void main(String[] args) throws ExecutionException {
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);
}
});
}
}
Guava Cache封装工具类
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.TimeUnit;
public final class JvmCacheUtil {
public static final String JVM_CACHE_SPECIFY_GEO = "cache_specify_geo";
public static final String JVM_CACHE_BUILD_SQL = "cache_build_sql";
public static final int DEFAULT_CAPACITY = 50;
public static final long DEFAULT_CACHE_EXP = 12L;
public static final long DEFAULT_CACHE_ENTRY_EXP = 900L;
/** * 12小时后过期 */
private static Cache<String,
Cache> cacheManager = CacheBuilder.newBuilder()
.maximumSize(DEFAULT_CAPACITY)
.expireAfterAccess(12L, TimeUnit.HOURS)
.expireAfterWrite(12L, TimeUnit.HOURS)
.initialCapacity(10)
.build();
public static Cache getCache(String cacheName) {
return getCache(cacheName, DEFAULT_CAPACITY, DEFAULT_CACHE_ENTRY_EXP, TimeUnit.SECONDS);
}
public static Cache getCache(String cacheName, long expire, TimeUnit timeUnit) {
return getCache(cacheName, DEFAULT_CAPACITY, expire, timeUnit);
}
public static Cache getCache(String cacheName, int capacity, long expire, TimeUnit timeUnit) {
Cache cache = cacheManager.getIfPresent(cacheName);
if (null == cache) {
cache = CacheBuilder.newBuilder()
.maximumSize(DEFAULT_CAPACITY)
.expireAfterAccess(expire, timeUnit)
.expireAfterWrite(expire, timeUnit)
.initialCapacity(capacity)
.build();
cacheManager.put(cacheName, cache);
}
return cache;
}
public static Object get(String cacheName, String key) {
Cache cache = getCache(cacheName);
return cache.getIfPresent(key);
}
public static void put(String cacheName, String key, Object val) {
Cache cache = getCache(cacheName);
cache.put(key, val);
}
public static void put(String cacheName, String key, Object val, long expire, TimeUnit timeUnit) {
Cache cache = getCache(cacheName, expire, timeUnit);
cache.put(key, val);
}
}
三、 常见缓存数据淘汰算法( FIFO + LRU + LFU)
四、Guava Cache原理
1、GuavaCache核心原理之数据结构
Guava Cache的数据结构跟ConcurrentHashMap类似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。
相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。其数据结构图如下：
-
LocalCache为Guava Cache的核心类，包含一个Segment数组组成 -
Segement数组的长度决定了cache的
并发数- 每一个Segment使用了单独的锁，其实每个Segment继承了ReentrantLock，对Segment的写操作需要先拿到锁
- 每个Segment由
一个table和5个队列组成
-
5个队列
- ReferenceQueue keyReferenceQueue ： 已经被GC，需要内部清理的
键引用队列 - ReferenceQueue valueReferenceQueue ： 已经被GC，需要内部清理的
值引用队列 - ConcurrentlinkedQueue<ReferenceEntry<k,v>> recencyQueue :
LRU队列，当segment上达到临界值发生写操作时该队列会移除数据 - Queue<ReferenceEntry<K, V>> writeQueue：
写队列，按照写入时间进行排序的元素队列，写入一个元素时会把它加入到队列尾部 - Queue<ReferenceEntry<K, V>> accessQueue：
访问队列，按照访问时间进行排序的元素队列，访问(包括写入)一个元素时会把它加入到队列尾部
- ReferenceQueue keyReferenceQueue ： 已经被GC，需要内部清理的
-
1个table
- AtomicReferenceArray<ReferenceEntry<K, V>> table：
AtomicReferenceArray可以用原子方式更新其元素的对象引用数组 - ReferenceEntry<K,V>, ReferenceEntry是Guava Cache中对一个键值对节点的抽象，每个ReferenceEntry数组项都是一条ReferenceEntry链。并且一个ReferenceEntry包含key、hash、valueReference、next字段（单链）
Guava Cache使用
ReferenceEntry接口来封装一个键值对，而用ValueReference来封装Value值 - AtomicReferenceArray<ReferenceEntry<K, V>> table：
2、GuavaCache核心原理之回收机制
Guava Cache提供了三种基本的缓存回收方式：
- 基于容量回收 maximumSize
- 在缓存项的数目达到限定值之前，采用
LRU + FIFO的回收方式
- 在缓存项的数目达到限定值之前，采用
- 定时回收 expireAfter
- expireAfterAccess：缓存项在给定时间内没有被读/写访问，则回收。回收顺序和基于大小回收一样（LRU）
- expireAfterWrite：缓存项在给定时间内没有被写访问（创建或覆盖），则回收
- 基于引用回收
- 通过使用弱引用的键、或弱引用的值、或软引用的值，Guava Cache可以垃圾回收
除了以上三种还有主动删除，采用命令: invalidateAll, invalidate
GuavaCache构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。
GuavaCache是在每次进行缓存操作的时候，惰性删除 如get()或者put()的时候，判断缓存是否过期
扫一扫
6122
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
