Guava Cache全面解析
緩存分為本地緩存和遠端緩存。常見的遠端緩存有Redis，MongoDB；本地緩存一般使用map的方式保存在本地內存中。一般我們在業(yè)務中操作緩存，都會操作緩存和數據源兩部分。如：put數據時，先插入DB，再刪除原來的緩存；ge數據時，先查緩存，命中則返回，沒有命中時，需要查詢DB，再把查詢結果放入緩存中 。如果訪問量大，我們還得兼顧本地緩存的線程安全問題。必要的時候也要考慮緩存的回收策略。
今天說的 Guava Cache 是google guava中的一個內存緩存模塊，用于將數據緩存到JVM內存中。他很好的解決了上面提到的幾個問題：
- 很好的封裝了get、put操作，能夠集成數據源 ；
- 線程安全的緩存，與ConcurrentMap相似，但前者增加了更多的元素失效策略，后者只能顯示的移除元素；
- Guava Cache提供了三種基本的緩存回收方式：基于容量回收、定時回收和基于引用回收。定時回收有兩種：按照寫入時間，最早寫入的最先回收；按照訪問時間，最早訪問的最早回收；
- 監(jiān)控緩存加載/命中情況
Guava Cache的架構設計靈感ConcurrentHashMap，在簡單場景中可以通過HashMap實現簡單數據緩存，但如果要實現緩存隨時間改變、存儲的數據空間可控則緩存工具還是很有必要的。Cache存儲的是鍵值對的集合，不同時是還需要處理緩存過期、動態(tài)加載等算法邏輯，需要額外信息實現這些操作，對此根據面向對象的思想，還需要做方法與數據的關聯(lián)性封裝，主要實現的緩存功能有：自動將節(jié)點加載至緩存結構中，當緩存的數據超過最大值時，使用LRU算法替換；它具備根據節(jié)點上一次被訪問或寫入時間計算緩存過期機制，緩存的key被封裝在WeakReference引用中，緩存的value被封裝在WeakReference或SoftReference引用中；還可以統(tǒng)計緩存使用過程中的命中率、異常率和命中率等統(tǒng)計數據。
構建緩存對象
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;
public class GuavaCacheService {
public void setCache() {
LoadingCache<Integer, String> cache = CacheBuilder.newBuilder()
//設置并發(fā)級別為8，并發(fā)級別是指可以同時寫緩存的線程數
.concurrencyLevel(8)
//設置緩存容器的初始容量為10
.initialCapacity(10)
//設置緩存最大容量為100，超過100之后就會按照LRU最近雖少使用算法來移除緩存項
.maximumSize(100)
//是否需要統(tǒng)計緩存情況,該操作消耗一定的性能,生產環(huán)境應該去除
.recordStats()
//設置寫緩存后n秒鐘過期
.expireAfterWrite(60, TimeUnit.SECONDS)
//設置讀寫緩存后n秒鐘過期,實際很少用到,類似于expireAfterWrite
//.expireAfterAccess(17, TimeUnit.SECONDS)
//只阻塞當前數據加載線程，其他線程返回舊值
//.refreshAfterWrite(13, TimeUnit.SECONDS)
//設置緩存的移除通知
.removalListener(notification -> {
System.out.println(notification.getKey() + " " + notification.getValue() + " 被移除,原因:" + notification.getCause());
})
//build方法中可以指定CacheLoader，在緩存不存在時通過CacheLoader的實現自動加載緩存
.build(new DemoCacheLoader());
//模擬線程并發(fā)
new Thread(() -> {
//非線程安全的時間格式化工具
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss");
try {
for (int i = 0; i < 10; i++) {
String value = cache.get(1);
System.out.println(Thread.currentThread().getName() + " " + simpleDateFormat.format(new Date()) + " " + value);
TimeUnit.SECONDS.sleep(3);
}
} catch (Exception ignored) {
}
}).start();
new Thread(() -> {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss");
try {
for (int i = 0; i < 10; i++) {
String value = cache.get(1);
System.out.println(Thread.currentThread().getName() + " " + simpleDateFormat.format(new Date()) + " " + value);
TimeUnit.SECONDS.sleep(5);
}
} catch (Exception ignored) {
}
}).start();
//緩存狀態(tài)查看
System.out.println(cache.stats().toString());
}
/**
* 隨機緩存加載,實際使用時應實現業(yè)務的緩存加載邏輯,例如從數據庫獲取數據
*/
public static class DemoCacheLoader extends CacheLoader<Integer, String> {
@Override
public String load(Integer key) throws Exception {
System.out.println(Thread.currentThread().getName() + " 加載數據開始");
TimeUnit.SECONDS.sleep(8);
Random random = new Random();
System.out.println(Thread.currentThread().getName() + " 加載數據結束");
return "value:" + random.nextInt(10000);
}
}
}LoadingCache是Cache的子接口，相比較于Cache，當從LoadingCache中讀取一個指定key的記錄時，如果該記錄不存在，則LoadingCache可以自動執(zhí)行加載數據到緩存的操作。
在調用CacheBuilder的build方法時，必須傳遞一個CacheLoader類型的參數，CacheLoader的load方法需要我們提供實現。當調用LoadingCache的get方法時，如果緩存不存在對應key的記錄，則CacheLoader中的load方法會被自動調用從外存加載數據，load方法的返回值會作為key對應的value存儲到LoadingCache中，并從get方法返回。
當然如果你不想指定重建策略，那么你可以使用無參的build()方法，它將返回Cache類型的構建對象。
CacheBuilder 是Guava 提供的一個快速構建緩存對象的工具類。CacheBuilder類采用builder設計模式，它的每個方法都返回CacheBuilder本身，直到build方法被調用。該類中提供了很多的參數設置選項，你可以設置cache的默認大小，并發(fā)數，存活時間，過期策略等等。
可選配置分析
緩存的并發(fā)級別
Guava提供了設置并發(fā)級別的api，使得緩存支持并發(fā)的寫入和讀取。同 ConcurrentHashMap 類似Guava cache的并發(fā)也是通過分離鎖實現。在一般情況下，將并發(fā)級別設置為服務器cpu核心數是一個比較不錯的選擇。
CacheBuilder.newBuilder()
// 設置并發(fā)級別為cpu核心數
.concurrencyLevel(Runtime.getRuntime().availableProcessors())
.build();緩存的初始容量設置
在構建緩存時可以為緩存設置一個合理大小初始容量，由于Guava的緩存使用了分離鎖的機制，擴容的代價非常昂貴。所以合理的初始容量能夠減少緩存容器的擴容次數。
CacheBuilder.newBuilder()
// 設置初始容量為100
.initialCapacity(100)
.build();設置最大存儲
Guava Cache可以在構建緩存對象時指定緩存所能夠存儲的最大記錄數量。當Cache中的記錄數量達到最大值后再調用put方法向其中添加對象，Guava會先從當前緩存的對象記錄中選擇一條刪除掉，騰出空間后再將新的對象存儲到Cache中。
- 基于容量的清除: 通過CacheBuilder.maximumSize(long)方法可以設置Cache的最大容量數，當緩存數量達到或接近該最大值時，Cache將清除掉那些最近最少使用的緩存;
- 基于權重的清除: 使用CacheBuilder.weigher(Weigher)指定一個權重函數，并且用CacheBuilder.maximumWeight(long)指定最大總重。比如每一項緩存所占據的內存空間大小都不一樣，可以看作它們有不同的“權重”（weights）。
緩存清除策略
- 基于存活時間的清除
expireAfterWrite 寫緩存后多久過期
expireAfterAccess 讀寫緩存后多久過期
refreshAfterWrite 寫入數據后多久過期,只阻塞當前數據加載線程,其他線程返回舊值
這幾個策略時間可以單獨設置,也可以組合配置。
- 上面提到的基于容量的清除
- 顯式清除
個別清除：Cache.invalidate(key)
批量清除：Cache.invalidateAll(keys)
清除所有緩存項：Cache.invalidateAll()
- 基于引用的清除
在構建Cache實例過程中，通過設置使用弱引用的鍵、或弱引用的值、或軟引用的值，從而使JVM在GC時順帶實現緩存的清除，不過一般不輕易使用這個特性。
- CacheBuilder.weakKeys()：使用弱引用存儲鍵。當鍵沒有其它（強或軟）引用時，緩存項可以被垃圾回收。因為垃圾回收僅依賴恒等式，使用弱引用鍵的緩存用而不是equals比較鍵。
- CacheBuilder.weakValues()：使用弱引用存儲值。當值沒有其它（強或軟）引用時，緩存項可以被垃圾回收。因為垃圾回收僅依賴恒等式，使用弱引用值的緩存用而不是equals比較值。
- CacheBuilder.softValues()：使用軟引用存儲值。軟引用只有在響應內存需要時，才按照全局最近最少使用的順序回收。考慮到使用軟引用的性能影響，我們通常建議使用更有性能預測性的緩存大小限定（見上文，基于容量回收）。使用軟引用值的緩存同樣用==而不是equals比較值。
清理什么時候發(fā)生
也許這個問題有點奇怪，如果設置的存活時間為一分鐘，難道不是一分鐘后這個key就會立即清除掉嗎？我們來分析一下如果要實現這個功能，那Cache中就必須存在線程來進行周期性地檢查、清除等工作，很多cache如redis、ehcache都是這樣實現的。
使用CacheBuilder構建的緩存不會”自動”執(zhí)行清理和回收工作，也不會在某個緩存項過期后馬上清理，也沒有諸如此類的清理機制。相反，它會在寫操作時順帶做少量的維護工作，或者偶爾在讀操作時做——如果寫操作實在太少的話。
這樣做的原因在于：如果要自動地持續(xù)清理緩存，就必須有一個線程，這個線程會和用戶操作競爭共享鎖。此外，某些環(huán)境下線程創(chuàng)建可能受限制，這樣CacheBuilder就不可用了。參考如下示例：
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class GuavaCacheService {
static Cache<Integer, String> cache = CacheBuilder.newBuilder()
.expireAfterWrite(5, TimeUnit.SECONDS)
.build();
public static void main(String[] args) throws Exception {
new Thread(() -> {
while (true) {
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
System.out.println(sdf.format(new Date()) + " size: " + cache.size());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
}
}).start();
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
cache.put(1, "a");
System.out.println("寫入 key:1 ,value:" + cache.getIfPresent(1));
Thread.sleep(10000);
cache.put(2, "b");
System.out.println("寫入 key:2 ,value:" + cache.getIfPresent(2));
Thread.sleep(10000);
System.out.println(sdf.format(new Date())
+ " sleep 10s , key:1 ,value:" + cache.getIfPresent(1));
System.out.println(sdf.format(new Date())
+ " sleep 10s, key:2 ,value:" + cache.getIfPresent(2));
}
}
部分輸出結果：
23:57:36 size: 0
寫入 key:1 ,value:a
23:57:38 size: 1
23:57:40 size: 1
23:57:42 size: 1
23:57:44 size: 1
23:57:46 size: 1
寫入 key:2 ,value:b
23:57:48 size: 1
23:57:50 size: 1
23:57:52 size: 1
23:57:54 size: 1
23:57:56 size: 1
23:57:56 sleep 10s , key:1 ,value:null
23:57:56 sleep 10s, key:2 ,value:null
23:57:58 size: 0
23:58:00 size: 0
23:58:02 size: 0
...
...上面程序設置了緩存過期時間為5S，每打印一次當前的size需要2S，打印了5次size之后寫入key 2，此時的size為1，說明在這個時候才把第一次應該過期的key 1給刪除。
給移除操作添加一個監(jiān)聽器：
可以為Cache對象添加一個移除監(jiān)聽器，這樣當有記錄被刪除時可以感知到這個事件：
RemovalListener<String, String> listener = notification -> System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
Cache<String,String> cache = CacheBuilder.newBuilder()
.maximumSize(5)
.removalListener(listener)
.build();但是要注意的是：默認情況下，監(jiān)聽器方法是在移除緩存時同步調用的。因為緩存的維護和請求響應通常是同時進行的，代價高昂的監(jiān)聽器方法在同步模式下會拖慢正常的緩存請求。在這種情況下，你可以使用RemovalListeners.asynchronous(RemovalListener, Executor)把監(jiān)聽器裝飾為異步操作。
自動加載
上面我們說過使用get方法的時候如果key不存在你可以使用指定方法去加載這個key。在Cache構建的時候通過指定CacheLoder的方式。如果你沒有指定，你也可以在get的時候顯式的調用call方法來設置key不存在的補救策略。
Cache的get方法有兩個參數，第一個參數是要從Cache中獲取記錄的key，第二個記錄是一個Callable對象。
當緩存中已經存在key對應的記錄時，get方法直接返回key對應的記錄。如果緩存中不包含key對應的記錄，Guava會啟動一個線程執(zhí)行Callable對象中的call方法，call方法的返回值會作為key對應的值被存儲到緩存中，并且被get方法返回。
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
public class GuavaCacheService {
private static 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("thread1"); //加載數據線程執(zhí)行標志
Thread.sleep(1000); //模擬加載時間
return "thread1";
}
});
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("thread2"); //加載數據線程執(zhí)行標志
Thread.sleep(1000); //模擬加載時間
return "thread2";
}
});
System.out.println("thread2 " + value);
} catch (ExecutionException e) {
e.printStackTrace();
}
}).start();
}
}
輸出結果為：
thread1
thread2
thread2
thread1 thread2
thread2 thread2可以看到輸出結果：兩個線程都啟動，輸出thread1，thread2，接著又輸出了thread2，說明進入了thread2的call方法了，此時thread1正在阻塞，等待key被設置。然后thread1 得到了value是thread2，thread2的結果自然也是thread2。
這段代碼中有兩個線程共享同一個Cache對象，兩個線程同時調用get方法獲取同一個key對應的記錄。由于key對應的記錄不存在，所以兩個線程都在get方法處阻塞。此處在call方法中調用Thread.sleep(1000)模擬程序從外存加載數據的時間消耗。
從結果中可以看出，雖然是兩個線程同時調用get方法，但只有一個get方法中的Callable會被執(zhí)行(沒有打印出load2)。Guava可以保證當有多個線程同時訪問Cache中的一個key時，如果key對應的記錄不存在，Guava只會啟動一個線程執(zhí)行get方法中Callable參數對應的任務加載數據存到緩存。當加載完數據后，任何線程中的get方法都會獲取到key對應的值。
統(tǒng)計信息
可以對Cache的命中率、加載數據時間等信息進行統(tǒng)計。在構建Cache對象時，可以通過CacheBuilder的recordStats方法開啟統(tǒng)計信息的開關。開關開啟后Cache會自動對緩存的各種操作進行統(tǒng)計，調用Cache的stats方法可以查看統(tǒng)計后的信息。
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
public class GuavaCacheService {
public static void main(String[] args) {
Cache<String, String> cache = CacheBuilder.newBuilder()
.maximumSize(3)
.recordStats() //開啟統(tǒng)計信息開關
.build();
cache.put("1", "v1");
cache.put("2", "v2");
cache.put("3", "v3");
cache.put("4", "v4");
cache.getIfPresent("1");
cache.getIfPresent("2");
cache.getIfPresent("3");
cache.getIfPresent("4");
cache.getIfPresent("5");
cache.getIfPresent("6");
System.out.println(cache.stats()); //獲取統(tǒng)計信息
}
}
輸出：
CacheStats{hitCount=3, missCount=3, loadSuccessCount=0, loadExceptionCount=0, totalLoadTime=0, evictionCount=1}
