Categories
程式開發

Guava-技術專題-Cache用法介紹


背景

緩存的主要作用是暫時在內存中保存業務系統的數據處理結果,並且等待下次訪問使用。在日長開發有很多場合,有一些數據量不是很大,不會經常改動,並且訪問非常頻繁。但是由於受限於硬盤IO的性能或者遠程網絡等原因獲取可能非常的費時。會導致我們的程序非常緩慢,這在某些業務上是不能忍的!而緩存正是解決這類問題的神器!

Guava-技術專題-Cache用法介紹 1

當然也並不是說你用了緩存你的系統就一定會變快,建議在用之前看一下使用緩存的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的用法進行詳細的介紹。

構建緩存對象

接口Cache代表一塊緩存,它有如下方法:

1 public interface Cache {
2 V get(K key, Callable valueLoader) throws ExecutionException;
4 ImmutableMap getAllPresent(Iterable keys);
6 void put(K key, V value);
8 void putAll(Map m);
10 void invalidate(Object key);
12 void invalidateAll(Iterable keys);
14 void invalidateAll();
16 long size();
18 CacheStats stats();
20 ConcurrentMap asMap();
22 void cleanUp();
23 }

可以通過CacheBuilder類構建一個緩存對象,CacheBuilder類採用builder設計模式,它的每個方法都返回CacheBuilder本身,直到build方法被調用。構建一個緩存對象代碼如下。

1 public class StudyGuavaCache {
2 public static void main(String[] args) {
3 Cache cache = CacheBuilder.newBuilder().build();
4 cache.put("word","Hello Guava Cache");
5 System.out.println(cache.getIfPresent("word"));
6 }
7 }

上面的代碼通過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)。

1 LoadingCache cache = CacheBuilder.newBuilder()
2 .build(
3 new CacheLoader() {
4 public Value load(Key key) throws AnyException {
5 return createValue(key);
6 }
7 });
8 ...
9 try {
10 return cache.get(key);
11 } catch (ExecutionException e) {
12 throw new OtherException(e.getCause());
13 }

設置最大存儲

Guava Cache可以在構建緩存對象時指定緩存所能夠存儲的最大記錄數量。當Cache中的記錄數量達到最大值後再調用put方法向其中添加對象,Guava會先從當前緩存的對象記錄中選擇一條刪除掉,騰出空間後再將新的對象存儲到Cache中。

1 public class StudyGuavaCache {
2 public static void main(String[] args) {
3 Cache cache = CacheBuilder.newBuilder()
4 .maximumSize(2).build();
6 cache.put("key1","value1");
7 cache.put("key2","value2");
8 cache.put("key3","value3");
9 System.out.println("第一个值:" + cache.getIfPresent("key1"));
10 System.out.println("第二个值:" + cache.getIfPresent("key2"));
11 System.out.println("第三个值:" + cache.getIfPresent("key3"));
12 }
13 }

上面代碼在構造緩存對象時,通過CacheBuilder類的maximumSize方法指定Cache最多可以存儲兩個對象,然後調用Cache的put方法向其中添加了三個對象。程序執行結果如下圖所示,可以看到第三條對象記錄的插入,導致了第一條對象記錄被刪除。

Guava-技術專題-Cache用法介紹 2

設置過期時間

構建Cache對象時,可以通過CacheBuilder類的expireAfterAccess和expireAfterWrite兩個方法為緩存中的對象指定過期時間,使用`CacheBuilder`構建的緩存不會“自動”執行清理和逐出值,也不會在值到期後立即執行或逐出任何類型。相反,它在寫入操作期間執行少量維護,或者在寫入很少的情況下偶爾執行讀取操作。其中,expireAfterWrite方法指定對像被寫入到緩存後多久過期,expireAfterAccess指定對像多久沒有被訪問後過期。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws InterruptedException {
3 Cache cache = CacheBuilder.newBuilder()
4 .maximumSize(2)
5 .expireAfterWrite(3,TimeUnit.SECONDS)
6 .build();
7 cache.put("key1","value1");
8 int time = 1;
9 while(true) {
10 System.out.println("第" + time++ + "次取到key1的值为:" + cache.getIfPresent("key1"));
11 Thread.sleep(1000);
12 }
13 }
14 }

上面的代碼在構造Cache對象時,通過CacheBuilder的expireAfterWrite方法指定put到Cache中的對像在3秒後會過期。在Cache對像中存儲一條對象記錄後,每隔1秒讀取一次這條記錄。程序運行結果如下圖所示,可以看到,前三秒可以從Cache中獲取到對象,超過三秒後,對像從Cache中被自動刪除。

Guava-技術專題-Cache用法介紹 3

下面代碼是expireAfterAccess的例子。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws InterruptedException {
3 Cache cache = CacheBuilder.newBuilder()
4 .maximumSize(2)
5 .expireAfterAccess(3,TimeUnit.SECONDS)
6 .build();
7 cache.put("key1","value1");
8 int time = 1;
9 while(true) {
10 Thread.sleep(time*1000);
11 System.out.println("睡眠" + time++ + "秒后取到key1的值为:" + cache.getIfPresent("key1"));
12 }
13 }
14 }

通過CacheBuilder的expireAfterAccess方法指定Cache中存儲的對像如果超過3秒沒有被訪問就會過期。 while中的代碼每sleep一段時間就會訪問一次Cache中存儲的對象key1,每次訪問key1之後下次sleep的時間會加長一秒。程序運行結果如下圖所示,從結果中可以看出,當超過3秒沒有讀取key1對象之後,該對象會自動被Cache刪除。

Guava-技術專題-Cache用法介紹 4

也可以同時用expireAfterAccess和expireAfterWrite方法指定過期時間,這時只要對象滿足兩者中的一個條件就會被自動過期刪除。

Guava Cache緩存過期後不一定會立馬被清理,一般會在Cache整體被讀取一定次數後清理。這中策略對性能是有好處的,如果想強制清理可以手動調用`Cache.cleanup()`或者使用`ScheduledExecutorService`來完成定期清理

弱引用

可以通過weakKeys和weakValues方法指定Cache只保存對緩存記錄key和value的弱引用。這樣當沒有其他強引用指向key和value時,key和value對象就會被垃圾回收器回收。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws InterruptedException {
3 Cache cache = CacheBuilder.newBuilder()
4 .maximumSize(2)
5 .weakValues()
6 .build();
7 Object value = new Object();
8 cache.put("key1",value);
10 value = new Object();//原对象不再有强引用
11 System.gc();
12 System.out.println(cache.getIfPresent("key1"));
13 }
14 }

上面代碼的打印結果是null。構建Cache時通過weakValues方法指定Cache只保存記錄值的一個弱引用。當給value引用賦值一個新的對象之後,就不再有任何一個強引用指向原對象。 System.gc()觸發垃圾回收後,原對象就被清除了。

顯示清除

可以調用Cache的invalidateAll或invalidate方法顯示刪除Cache中的記錄。 invalidate方法一次只能刪除Cache中一個記錄,接收的參數是要刪除記錄的key。 invalidateAll方法可以批量刪除Ca​​che中的記錄,當沒有傳任何參數時,invalidateAll方法將清除Cache中的全部記錄。 invalidateAll也可以接收一個Iterable類型的參數,參數中包含要刪除記錄的所有key值。下面代碼對此做了示例。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws InterruptedException {
3 Cache cache = CacheBuilder.newBuilder().build();
4 Object value = new Object();
5 cache.put("key1","value1");
6 cache.put("key2","value2");
7 cache.put("key3","value3");
9 List list = new ArrayList();
10 list.add("key1");
11 list.add("key2");
13 cache.invalidateAll(list);
//批量清除list中全部key对应的记录
14 System.out.println(cache.getIfPresent("key1"));
15 System.out.println(cache.getIfPresent("key2"));
16 System.out.println(cache.getIfPresent("key3"));
17 }
18 }

代碼中構造了一個集合list用於保存要刪除記錄的key值,然後調用invalidateAll方法批量刪除key1和key2對應的記錄,只剩下key3對應的記錄沒有被刪除。

移除監聽器

可以為Cache對象添加一個移除監聽器,這樣當有記錄被刪除時可以感知到這個事件。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws InterruptedException {
3 RemovalListener listener = new RemovalListener() {
4 public void onRemoval(RemovalNotification notification) {
5 System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
6 }
7 };
8 Cache cache = CacheBuilder.newBuilder()
9 .maximumSize(3)
10 .removalListener(listener).build();
12 Object value = new Object();
13 cache.put("key1","value1");
14 cache.put("key2","value2");
15 cache.put("key3","value3");
16 cache.put("key4","value3");
17 cache.put("key5","value3");
18 cache.put("key6","value3");
19 cache.put("key7","value3");
20 cache.put("key8","value3");
21 }
22 }

removalListener方法為Cache指定了一個移除監聽器,這樣當有記錄從Cache中被刪除時,監聽器listener就會感知到這個事件。程序運行結果如下圖所示。

Guava-技術專題-Cache用法介紹 5

自動加載

Cache的get方法有兩個參數,第一個參數是要從Cache中獲取記錄的key,第二個記錄是一個Callable對象。當緩存中已經存在key對應的記錄時,get方法直接返回key對應的記錄。如果緩存中不包含key對應的記錄,Guava會啟動一個線程執行Callable對像中的call方法,call方法的返回值會作為key對應的值被存儲到緩存中,並且被get方法返回。下面是一個多線程的例子:

1 public class StudyGuavaCache {
3 private static Cache cache = CacheBuilder.newBuilder()
4 .maximumSize(3)
5 .build();
7 public static void main(String[] args) throws InterruptedException {
9 new Thread(new Runnable() {
10 public void run() {
11 System.out.println("thread1");
12 try {
13 String value = cache.get("key", new Callable() {
14 public String call() throws Exception {
15 System.out.println("load1"); //加载数据线程执行标志
16 Thread.sleep(1000); //模拟加载时间
17 return "auto load by Callable";
18 }
19 });
20 System.out.println("thread1 " + value);
21 } catch (ExecutionException e) {
22 e.printStackTrace();
23 }
24 }
25 }).start();
27 new Thread(new Runnable() {
28 public void run() {
29 System.out.println("thread2");
30 try {
31 String value = cache.get("key", new Callable() {
32 public String call() throws Exception {
33 System.out.println("load2"); //加载数据线程执行标志
34 Thread.sleep(1000); //模拟加载时间
35 return "auto load by Callable";
36 }
37 });
38 System.out.println("thread2 " + value);
39 } catch (ExecutionException e) {
40 e.printStackTrace();
41 }
42 }
43 }).start();
44 }
45 }

這段代碼中有兩個線程共享同一個Cache對象,兩個線程同時調用get方法獲取同一個key對應的記錄。由於key對應的記錄不存在,所以兩個線程都在get方法處阻塞。此處在call方法中調用Thread.sleep(1000)模擬程序從外存加載數據的時間消耗。代碼的執行結果如下圖:

Guava-技術專題-Cache用法介紹 6

從結果中可以看出,雖然是兩個線程同時調用get方法,但只有一個get方法中的Callable會被執行(沒有打印出load2)。 Guava可以保證當有多個線程同時訪問Cache中的一個key時,如果key對應的記錄不存在,Guava只會啟動一個線程執行get方法中Callable參數對應的任務加載數據存到緩存。當加載完數據後,任何線程中的get方法都會獲取到key對應的值。

統計信息

可以對Cache的命中率、加載數據時間等信息進行統計。在構建Cache對象時,可以通過CacheBuilder的recordStats方法開啟統計信息的開關。開關開啟後Cache會自動對緩存的各種操作進行統計,調用Cache的stats方法可以查看統計後的信息。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws InterruptedException {
3 Cache cache = CacheBuilder.newBuilder()
4 .maximumSize(3)
5 .recordStats() //开启统计信息开关
6 .build();
7 cache.put("key1","value1");
8 cache.put("key2","value2");
9 cache.put("key3","value3");
10 cache.put("key4","value4");
12 cache.getIfPresent("key1");
13 cache.getIfPresent("key2");
14 cache.getIfPresent("key3");
15 cache.getIfPresent("key4");
16 cache.getIfPresent("key5");
17 cache.getIfPresent("key6");
19 System.out.println(cache.stats()); //获取统计信息
20 }
21 }

程序執行結果如下圖所示:

Guava-技術專題-Cache用法介紹 7

這些統計信息對於調整緩存設置是至關重要的,在性能要求高的應用中應該密切關注這些數據

正在加載緩存

LoadingCache是​​Cache的子接口,相比較於Cache,當從LoadingCache中讀取一個指定key的記錄時,如果該記錄不存在,則LoadingCache可以自動執行加載數據到緩存的操作。 LoadingCache接口的定義如下:

1 public interface LoadingCache extends Cache, Function {
2
3 V get(K key) throws ExecutionException;
4
5 V getUnchecked(K key);
6
7 ImmutableMap getAll(Iterable keys) throws ExecutionException;
9 V apply(K key);
10
11 void refresh(K key);
12
13 @Override
14 ConcurrentMap asMap();
15 }

與構建Cache類型的對像類似,LoadingCache類型的對像也是通過CacheBuilder進行構建,不同的是,在調用CacheBuilder的build方法時,必須傳遞一個CacheLoader類型的參數,CacheLoader的load方法需要我們提供實現。當調用LoadingCache的get方法時,如果緩存不存在對應key的記錄,則CacheLoader中的load方法會被自動調用從外存加載數據,load方法的返回值會作為key對應的value存儲到LoadingCache中,並從get方法返回。

1 public class StudyGuavaCache {
2 public static void main(String[] args) throws ExecutionException {
3 CacheLoader loader = new CacheLoader () {
4 public String load(String key) throws Exception {
5 Thread.sleep(1000); //休眠1s,模拟加载数据
6 System.out.println(key + " is loaded from a cacheLoader!");
7 return key + "'s value";
8 }
9 };
11 LoadingCache loadingCache = CacheBuilder.newBuilder()
12 .maximumSize(3)
13 .build(loader);//在构建时指定自动加载器
15 loadingCache.get("key1");
16 loadingCache.get("key2");
17 loadingCache.get("key3");
18 }
19 }

程序執行結果如下圖所示:

Guava-技術專題-Cache用法介紹 8