Guava Cache用法介紹
背景
緩存的主要做用是暫時在內存中保存業務系統的數據處理結果，而且等待下次訪問使用。在日長開發有不少場合，有一些數據量不是很大，不會常常改動，而且訪問很是頻繁。可是因爲受限於硬盤IO的性能或者遠程網絡等緣由獲取可能很是的費時。會致使咱們的程序很是緩慢，這在某些業務上是不能忍的！而緩存正是解決這類問題的神器！java
固然也並非說你用了緩存你的系統就必定會變快，建議在用以前看一下使用緩存的9大誤區(上) 使用緩存的9大誤區(下)redis
緩存在不少系統和架構中都用普遍的應用,例如：數據庫
- CPU緩存
- 操做系統緩存
- HTTP緩存
- 數據庫緩存
- 靜態文件緩存
- 本地緩存
- 分佈式緩存
能夠說在計算機和網絡領域，緩存是無處不在的。能夠這麼說，只要有硬件性能不對等，涉及到網絡傳輸的地方都會有緩存的身影。segmentfault
緩存整體可分爲兩種 集中式緩存 和 分佈式緩存設計模式
「集中式緩存"與"分佈式緩存"的區別其實就在於「集中」與"非集中"的概念，其對象多是服務器、內存條、硬盤等。好比：緩存
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<K, V> { 2 V get(K key, Callable<? extends V> valueLoader) throws ExecutionException; 3 4 ImmutableMap<K, V> getAllPresent(Iterable<?> keys); 5 6 void put(K key, V value); 7 8 void putAll(Map<? extends K, ? extends V> m); 9 10 void invalidate(Object key); 11 12 void invalidateAll(Iterable<?> keys); 13 14 void invalidateAll(); 15 16 long size(); 17 18 CacheStats stats(); 19 20 ConcurrentMap<K, V> asMap(); 21 22 void cleanUp(); 23 }
能夠經過CacheBuilder類構建一個緩存對象，CacheBuilder類採用builder設計模式，它的每一個方法都返回CacheBuilder自己，直到build方法被調用。構建一個緩存對象代碼以下。
1 public class StudyGuavaCache { 2 public static void main(String[] args) { 3 Cache<String,String> 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提供了不少更強大的功能。
get(K)方法。這個方法要麼返回已經緩存的值，要麼使用CacheLoader向緩存原子地加載新值（經過
load(String key) 方法加載）。因爲CacheLoader可能拋出異常，
LoadingCache.get(K)也聲明拋出ExecutionException異常。若是你定義的CacheLoader沒有聲明任何檢查型異常，則能夠經過
getUnchecked(K)查找緩存；但必須注意，一旦CacheLoader聲明瞭檢查型異常，就不能夠調用
getUnchecked(K)。
1 LoadingCache<Key, Value> cache = CacheBuilder.newBuilder() 2 .build( 3 new CacheLoader<Key, Value>() { 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<String,String> cache = CacheBuilder.newBuilder() 4 .maximumSize(2) 5 .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方法向其中添加了三個對象。程序執行結果以下圖所示，能夠看到第三條對象記錄的插入，致使了第一條對象記錄被刪除。
設置過時時間
在構建Cache對象時，能夠經過CacheBuilder類的expireAfterAccess和expireAfterWrite兩個方法爲緩存中的對象指定過時時間，過時的對象將會被緩存自動刪除。其中，expireAfterWrite方法指定對象被寫入到緩存後多久過時，expireAfterAccess指定對象多久沒有被訪問後過時。
1 public class StudyGuavaCache { 2 public static void main(String[] args) throws InterruptedException { 3 Cache<String,String> 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中被自動刪除。
下面代碼是expireAfterAccess的例子。
1 public class StudyGuavaCache { 2 public static void main(String[] args) throws InterruptedException { 3 Cache<String,String> 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刪除。
也能夠同時用expireAfterAccess和expireAfterWrite方法指定過時時間，這時只要對象知足二者中的一個條件就會被自動過時刪除。
弱引用
能夠經過weakKeys和weakValues方法指定Cache只保存對緩存記錄key和value的弱引用。這樣當沒有其餘強引用指向key和value時，key和value對象就會被垃圾回收器回收。
1 public class StudyGuavaCache { 2 public static void main(String[] args) throws InterruptedException { 3 Cache<String,Object> cache = CacheBuilder.newBuilder() 4 .maximumSize(2) 5 .weakValues() 6 .build(); 7 Object value = new Object(); 8 cache.put("key1",value); 9 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方法能夠批量刪除Cache中的記錄，當沒有傳任何參數時，invalidateAll方法將清除Cache中的所有記錄。invalidateAll也能夠接收一個Iterable類型的參數，參數中包含要刪除記錄的全部key值。下面代碼對此作了示例。
1 public class StudyGuavaCache { 2 public static void main(String[] args) throws InterruptedException { 3 Cache<String,String> cache = CacheBuilder.newBuilder().build(); 4 Object value = new Object(); 5 cache.put("key1","value1"); 6 cache.put("key2","value2"); 7 cache.put("key3","value3"); 8 9 List<String> list = new ArrayList<String>(); 10 list.add("key1"); 11 list.add("key2"); 12 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<String, String> listener = new RemovalListener<String, String>() { 4 public void onRemoval(RemovalNotification<String, String> notification) { 5 System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!"); 6 } 7 }; 8 Cache<String,String> cache = CacheBuilder.newBuilder() 9 .maximumSize(3) 10 .removalListener(listener) 11 .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就會感知到這個事件。程序運行結果以下圖所示。
自動加載
Cache的get方法有兩個參數，第一個參數是要從Cache中獲取記錄的key，第二個記錄是一個Callable對象。當緩存中已經存在key對應的記錄時，get方法直接返回key對應的記錄。若是緩存中不包含key對應的記錄，Guava會啓動一個線程執行Callable對象中的call方法，call方法的返回值會做爲key對應的值被存儲到緩存中，而且被get方法返回。下面是一個多線程的例子：
1 public class StudyGuavaCache { 2 3 private static Cache<String,String> cache = CacheBuilder.newBuilder() 4 .maximumSize(3) 5 .build(); 6 7 public static void main(String[] args) throws InterruptedException { 8 9 new Thread(new Runnable() { 10 public void run() { 11 System.out.println("thread1"); 12 try { 13 String value = cache.get("key", new Callable<String>() { 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(); 26 27 new Thread(new Runnable() { 28 public void run() { 29 System.out.println("thread2"); 30 try { 31 String value = cache.get("key", new Callable<String>() { 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)模擬程序從外存加載數據的時間消耗。代碼的執行結果以下圖：
從結果中能夠看出，雖然是兩個線程同時調用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<String,String> 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"); 11 12 cache.getIfPresent("key1"); 13 cache.getIfPresent("key2"); 14 cache.getIfPresent("key3"); 15 cache.getIfPresent("key4"); 16 cache.getIfPresent("key5"); 17 cache.getIfPresent("key6"); 18 19 System.out.println(cache.stats()); //獲取統計信息 20 } 21 }
程序執行結果以下圖所示：
這些統計信息對於調整緩存設置是相當重要的，在性能要求高的應用中應該密切關注這些數據
LoadingCache
LoadingCache是Cache的子接口，相比較於Cache，當從LoadingCache中讀取一個指定key的記錄時，若是該記錄不存在，則LoadingCache能夠自動執行加載數據到緩存的操做。LoadingCache接口的定義以下：
1 public interface LoadingCache<K, V> extends Cache<K, V>, Function<K, V> { 2 3 V get(K key) throws ExecutionException; 4 5 V getUnchecked(K key); 6 7 ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException; 8 9 V apply(K key); 10 11 void refresh(K key); 12 13 @Override 14 ConcurrentMap<K, V> 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<String, String> loader = new CacheLoader<String, String> () { 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 }; 10 11 LoadingCache<String,String> loadingCache = CacheBuilder.newBuilder() 12 .maximumSize(3) 13 .build(loader);//在構建時指定自動加載器 14 15 loadingCache.get("key1"); 16 loadingCache.get("key2"); 17 loadingCache.get("key3"); 18 } 19 }
程序執行結果以下圖所示：
轉自：
- 1. Guava Cache用法介紹
- 2. Guava Cache用法介紹<轉>
- 3. 【Guava】Guava Cache用法
- 4. Guava------------Cache使用方法
- 5. Guava cache 用法學習
- 6. Guava Cache
- 7. Guava cache
- 8. guava cache
- 9. Guava Cache的使用
- 10. Google Guava Collections 使用介紹
- 更多相關文章...
- • 網站主機 介紹 - 網站主機教程
- • Spring目錄結構和基礎JAR包介紹 - Spring教程
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
- • C# 中 foreach 遍歷的用法
-
每一个你不满意的现在，都有一个你没有努力的曾经。