一、緩存簡介

緩存，筆者的理解是讓數據更接近于使用者，目的是讓訪問速度更多。工作機制是先從緩存中讀取數據，如果沒有，則再從慢速設備上讀取實際數據并同步到緩存。那些經常讀取的數據、頻繁訪問的數據、熱點數據、IO瓶頸數據、計算昂貴的數據、符合五分鐘法則和局部性原理的數據都可以進行緩存。如CPU→L1/L2/L3→內存→磁盤就是一個典型的例子，CPU需要數據時先從L1讀取，如果沒有找到，則查找L2/L3讀取，如果沒有，則到內存中查找，如果還沒有，則會到磁盤中查找。還有比如用過Maven的朋友都應該知道，加載依賴的時候，先從本機倉庫找，再從本地服務器倉庫找，最后到遠程倉庫服務器找。還有如京東的物流為什么那么快?他們在各地都有分倉庫，如果該倉庫有貨物，那么送貨的速度是非?？斓摹?/p>

本文以Java應用緩存為示例進行講解。

二、緩存命中率

緩存命中率是從緩存中讀取數據的次數與總讀取次數的比率，命中率越高越好。緩存命中率 = 從緩存中讀取次數/〔總讀取次數(從緩存中讀取次數 + 從慢速設備上讀取的次數)〕。這是一個非常重要的監控指標，如果做緩存，則應通過監控這個指標來看緩存是否工作良好。

三、緩存回收策略

1. 基于空間

即設置緩存的存儲空間，如設置為10MB，當達到存儲空間時，按照一定的策略移除數據。

2. 基于容量

基于容量指緩存設置了最大大小，當緩存的條目超過最大大小，則按照一定的策略將舊數據移除。

3. 基于時間

TTL(Time To Live )：存活期，即緩存數據從緩存中創建時間開始直到它到期的一個時間段(不管在這個時間段內有沒有訪問都將過期)。

TTI(Time To Idle)：空閑期，即緩存數據多久沒被訪問過將從緩存中移除的時間。

4. 基于Java對象引用

軟引用：如果一個對象是軟引用，那么當JVM堆內存不足時，垃圾回收器可以回收這些對象。軟引用適合用來做緩存，從而當JVM堆內存不足時，可以回收這些對象騰出一些空間供強引用對象使用，從而避免OOM。

弱引用：當垃圾回收器回收內存時，如果發現弱引用，則將立即回收它。相對于軟引用有更短的生命周期。

注意：弱引用/軟引用對象只有當沒有其他強引用對象引用它時，垃圾回收時才回收該引用。即如果有一個對象(不是弱引用/軟引用)引用了弱引用/軟引用對象，那么垃圾回收時不會回收該引用對象。

5. 回收算法

使用基于空間和基于容量的會使用一定的策略移除舊數據，常見的如下。

• FIFO(First In First Out)：先進先出算法，即先放入緩存的先被移除。
• LRU(Least Recently Used)：最近最少使用算法，使用時間距離現在最久的那個被移除。
• LFU(Least Frequently Used)：最不常用算法，一定時間段內使用次數(頻率)最少的那個被移除。

實際應用中基于LRU的緩存居多，如Guava Cache、Ehcache支持LRU。

四、Java緩存類型

• 堆緩存：使用Java堆內存來存儲緩存對象。使用堆緩存的好處是沒有序列化/反序列化，是最快的緩存。缺點也很明顯，當緩存的數據量很大時， GC暫停時間會變長，存儲容量受限于堆空間大小。一般通過軟引用/弱引用來存儲緩存對象，即當堆內存不足時，可以強制回收這部分內存釋放堆內存空間。一般使用堆緩存存儲較熱的數據?？梢允褂肎uava Cache、Ehcache 3.x、MapDB實現。

• 堆外緩存：即緩存數據存儲在堆外內存，可以減少GC暫停時間(堆對象轉移到堆外，GC掃描和移動的對象變少了)，可以支持更大的緩存空間(只受機器內存大小限制，不受堆空間的影響)。但是，讀取數據時需要序列化/反序列化，因此，會比堆緩存慢很多?？梢允褂肊hcache 3.x、MapDB實現。

• 磁盤緩存：即緩存數據的存儲在磁盤上，當JVM重啟時數據還是在的。而堆緩存/堆外緩存重啟時數據會丟失，需要重新加載?？梢允褂肊hcache 3.x、MapDB實現。

• 分布式緩存：上文提到的緩存是進程內緩存和磁盤緩存，在多JVM實例的情況時，會存在兩個問題：1.單機容量問題;2.數據一致性問題(多臺JVM實例的緩存數據不一致怎么辦)，不過，這個問題不用太糾結，既然數據允許緩存，則表示允許一定時間內的不一致，因此，可以設置緩存數據的過期時間來定期更新數據;3.緩存不命中時，需要回源到DB/服務查詢變多：每個實例在緩存不命中情況下都會回源到DB加載數據，因此，多實例后DB整體的訪問量就變多了，解決辦法可以使用如一致性哈希分片算法來解決。因此，這些情況可以考慮使用分布式緩存來解決。可以使用ehcache-clustered(配合Terracotta server)實現Java進程間分布式緩存。當然也可以使用如Redis實現分布式緩存。

兩種模式如下。

● 單機時：存儲最熱的數據到堆緩存，相對熱的數據到堆外緩存，不熱的數據存到磁盤緩存。

● 集群時：存儲最熱的數據到堆緩存，相對熱的數據到堆外緩存，全量數據存到分布式緩存。

接下來，我們看看如何在Java中使用堆緩存、堆外緩存、磁盤緩存、分布式緩存，是不是感覺像L1、L2、L3級緩存架構。

Guava Cache只提供堆緩存，小巧靈活，性能最好，如果只使用堆緩存，那么使用它就夠了。

EhCache3.x提供了堆緩存、堆外緩存、磁盤緩存、分布式緩存。但是，其代碼注釋比較少，API還不完善(比如，2.x支持LRU、LFU、FIFO，而3.x目前還沒有API設置)，功能還不完善(比如，集群情況個人測試其暫時不可以生產環境使用)，如果需要較穩定的API和功能，則請考慮使用EhCache2.x(不支持堆外緩存)。

MapDB是一款嵌入式Java數據庫引擎和集合框架。提供了Maps、Sets、Lists、Queues、Bitmaps的支持，還支持ACID事務，增量備份。支持堆緩存、堆外緩存、磁盤緩存。

1. 堆緩存

Gauva Cache實現

Cache<String, String> myCache= 
        CacheBuilder.newBuilder() 
                .concurrencyLevel(4) 
                .expireAfterWrite(10, TimeUnit.SECONDS) 
                .maximumSize(10000) 
                .build(); 

然后可以通過put、getIfPresent來讀寫緩存。CacheBuilder有幾類參數：緩存回收策略、并發設置、統計命中率等。

(1) 緩存回收策略/基于容量

maximumSize：設置緩存的容量，當超出maximumSize時，按照LRU進行緩存回收。

(2) 緩存回收策略/基于時間

• expireAfterWrite：設置TTL，緩存數據在給定的時間內沒有寫(創建/覆蓋)時，則被回收，即定期的會回收緩存數據。
• expireAfterAccess：設置TTI，緩存數據在給定的時間內沒有讀/寫時，則被回收。每次訪問時，都會更新它的TTI，從而如果該緩存是非常熱的數據，則將一直不過期，可能會導致臟數據存在很長時間(因此，建議設置expireAfterWrite)。

(3) 緩存回收策略/基于Java對象引用

• weakKeys/weakValues：設置弱引用緩存。
• softValues：設置軟引用緩存。

(4) 緩存回收策略/主動失效

invalidate(Object key)/ invalidateAll(Iterablekeys)/invalidateAll()：主動失效某些緩存數據。

什么時候觸發失效呢?Guava Cache不會在緩存數據失效時立即觸發回收操作(如果要這么做，則需要有額外的線程來進行清理)，是在PUT時會主動進行一次清理緩存，當然讀者也可以根據實際業務通過自己設計線程來調用cleanUp方法進行清理。

(5) 并發級別

concurrencyLevel：Guava Cache重寫了ConcurrentHashMap，concurrencyLevel用來設置Segment數量，concurrencyLevel越大并發能力越強。

(6) 統計命中率

recordStats：啟動記錄統計信息，比如命中率等。

(7) EhCache 3.x實現

本文使用最新的Ehcache3.1.2，目前Ehcache3.x版本還比較新，一些文檔還不是很全。

CacheManager cacheManager = CacheManagerBuilder. newCacheManagerBuilder(). build(true); 
CacheConfigurationBuilder<String, String> cacheConfig= CacheConfigurationBuilder.newCacheConfigurationBuilder( 
       String.class, 
       String.class, 
       ResourcePoolsBuilder.newResourcePoolsBuilder() 
               .heap(100, EntryUnit.ENTRIES)) 
       .withDispatcherConcurrency(4) 
       .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS))); 
  
Cache<String, String> myCache = cacheManager.createCache("myCache",cacheConfig); 

CacheManager在JVM關閉時請調用CacheManager.close()方法。 可以通過PUT、GET來讀寫緩存。CacheConfigurationBuilder也有幾類參數：緩存回收策略、并發設置、統計命中率等。

(8) 緩存回收策略/基于容量

heap(100, EntryUnit.ENTRIES)：設置緩存的條目數量，當超出此數量時按照LRU進行緩存回收。

(9) 緩存回收策略/基于空間

heap(100, MemoryUnit.MB)：設置緩存的內存空間，當超出此空間時按照LRU進行緩存回收。另外，應該設置withSizeOfMaxObjectGraph(2)：統計對象大小時對象圖遍歷深度和withSizeOfMaxObjectSize(1, MemoryUnit.KB)：可緩存的最大對象大小。

(10) 緩存回收策略/基于時間

• withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS)))：設置TTL，沒有TTI。
• withExpiry(Expirations.timeToIdleExpiration(Duration.of(10,TimeUnit.SECONDS)))：同時設置TTL和TTI，且TTL和TTI值一樣。

(11) 緩存回收策略/主動失效

remove(K key)/ removeAll(Set keys)/clear()：主動失效某些緩存數據。

什么時候觸發失效呢?EhCache使用了類似于Guava Cache同樣的機制。

(12) 并發級別

目前還沒有提供API來設置，EhCache內部使用ConcurrentHashMap作為緩存存儲，默認并發級別16。withDispatcherConcurrency是用來設置事件分發時的并發級別。

(13) 統計命中率

目前還沒有開放API來統計。

MapDB 3.x實現

HTreeMap myCache = 
       DBMaker.heapDB().concurrencyScale(16).make().hashMap("myCache") 
       .expireMaxSize(10000) 
       .expireAfterCreate(10, TimeUnit.SECONDS) 
        .expireAfterUpdate(10,TimeUnit.SECONDS) 
       .expireAfterGet(10, TimeUnit.SECONDS) 
       .create(); 

然后可以通過PUT、GET來讀寫緩存。其有幾類參數：緩存回收策略、并發設置、統計命中率等。

a. 緩存回收策略/基于容量

expireMaxSize：設置緩存的容量，當超出expireMaxSize時，按照LRU進行緩存回收。

b. 緩存回收策略/基于時間

expireAfterCreate/expireAfterUpdate：設置TTL，緩存數據在給定的時間內沒有寫(創建/覆蓋)時，則被回收。即定期的會回收緩存數據。

expireAfterGet：設置TTI， 緩存數據在給定的時間內沒有讀/寫時，則被回收。每次訪問時都會更新它的TTI，從而如果該緩存是非常熱的數據，則將一直不過期，可能會導致臟數據存在很長的時間(因此，建議要設置expireAfterCreate/expireAfterUpdate)。

c. 緩存回收策略/主動失效

remove(Object key) /clear()：主動失效某些緩存數據。

什么時候觸發失效呢?MapDB默認使用類似于Guava Cache的機制。不過，也支持可以通過如下配置使用線程池定期進行緩存失效。

.expireExecutor(scheduledExecutorService) 
.expireExecutorPeriod(3000) 

d. 并發級別

concurrencyScale：類似于Guava Cache配置。

e. 統計命中率

暫無。

還可以使用DBMaker.memoryDB()創建堆緩存，它將數據序列化并存儲到1MB大小的byte[]數組中，從而減少垃圾回收的影響。

2. 堆外緩存

EhCache 3.x實現

CacheConfigurationBuilder<String, String> cacheConfig= CacheConfigurationBuilder.newCacheConfigurationBuilder( 
       String.class, 
       String.class, 
       ResourcePoolsBuilder.newResourcePoolsBuilder() 
               .offheap(100, MemoryUnit.MB)) 
       .withDispatcherConcurrency(4) 
       .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS))) 
       .withSizeOfMaxObjectGraph(3) 
       .withSizeOfMaxObjectSize(1, MemoryUnit.KB); 

堆外緩存不支持基于容量的緩存過期策略。

MapDB 3.x實現

HTreeMap myCache = 
       DBMaker.memoryDirectDB().concurrencyScale(16).make().hashMap("myCache") 
       .expireStoreSize(64 * 1024 * 1024) //指定堆外緩存大小64MB 
       .expireMaxSize(10000) 
       .expireAfterCreate(10, TimeUnit.SECONDS) 
       .expireAfterUpdate(10, TimeUnit.SECONDS) 
       .expireAfterGet(10, TimeUnit.SECONDS) 
       .create(); 

在使用堆外緩存時，請記得添加JVM啟動參數，如-XX:MaxDirectMemorySize=10G。

3. 磁盤緩存

EhCache 3.x實現

CacheManager cacheManager = CacheManagerBuilder. newCacheManagerBuilder() 
        //默認線程池 
        .using(PooledExecutionServiceConfigurationBuilder.newPooledExecutionServiceConfigurationBuilder().defaultPool("default",1, 10).build()) 
        //磁盤文件存儲位置 
        .with(new CacheManagerPersistenceConfiguration(newFile("D:\\bak"))) 
       .build(true); 
  
CacheConfigurationBuilder<String, String> cacheConfig= CacheConfigurationBuilder. newCacheConfigurationBuilder( 
       String.class, 
       String.class, 
       ResourcePoolsBuilder.newResourcePoolsBuilder() 
                .disk(100, MemoryUnit.MB,true)) //磁盤緩存 
        .withDiskStoreThreadPool("default", 5) //使用"default"線程池進行dump文件到磁盤 
        .withExpiry(Expirations.timeToLiveExpiration(Duration.of(50,TimeUnit.SECONDS))) 
       .withSizeOfMaxObjectGraph(3) 
       .withSizeOfMaxObjectSize(1, MemoryUnit.KB); 

在JVM停止時，記得調用cacheManager.close()，從而保證內存數據能dump到磁盤。

MapDB 3.x實現

DB db = DBMaker 
        .fileDB("D:\\bak\\a.data")//數據存哪里 
        .fileMmapEnable() //啟用mmap 
        .fileMmapEnableIfSupported() //在支持的平臺上啟用mmap 
        .fileMmapPreclearDisable() //讓mmap文件更快 
        .cleanerHackEnable() //一些BUG處理 
        .transactionEnable() //啟用事務 
        .closeOnJvmShutdown() 
       .concurrencyScale(16) 
       .make(); 
  
HTreeMap myCache = db.hashMap("myCache") 
       .expireMaxSize(10000) 
       .expireAfterCreate(10, TimeUnit.SECONDS) 
       .expireAfterUpdate(10, TimeUnit.SECONDS) 
       .expireAfterGet(10, TimeUnit.SECONDS) 
       .createOrOpen(); 

因為開啟了事務，MapDB則開啟了WAL。另外，操作完緩存后記得調用db.commit方法提交事務。

myCache.put("key" + counterWriter,"value" + counterWriter); 
db.commit(); 

4. 分布式緩存

本文使用Ehcache 3.1+Terracottaserver實現，Ehcache 3.1引入了一個下載套件，其包含了Terracotta Server。

調用start-tc-server腳本啟動tc server。

(1) 架構

Terracotta Server配置

<?xml version="1.0"encoding="UTF-8"?> 
<tc-configxmlnstc-configxmlns="http://www.terracotta.org/config" 
          xmlns:ohr="http://www.terracotta.org/config/offheap-resource"> 
  
 <servers> 
    <server host="192.168.147.50" name="s1"> 
     <tsa-port>9510</tsa-port> 
     <tsa-group-port>9530</tsa-group-port> 
   </server> 
  
    <server host="192.168.147.52" name="s2"> 
     <tsa-port>9510</tsa-port> 
     <tsa-group-port>9530</tsa-group-port> 
   </server> 
  
  <client-reconnect-window>30</client-reconnect-window> 
  <restartable enabled="true"/> 
   </servers> 
  
   <services> 
       <service id="resources"> 
           <ohr:offheap-resources> 
               <ohr:resource name="cache"unit="MB">64</ohr:resource> 
           </ohr:offheap-resources> 
       </service> 
   </services> 
</tc-config> 

配置了兩個tc server，其中一主一備。在兩臺服務器中分別調用如下腳本啟動兩臺tc server。

./start-tc-server.sh -f tc-config.xml  -n s1 
./start-tc-server.sh -f tc-config.xml  -n s2 

(2) EhCache代碼片段

CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder= 
       CacheManagerBuilder.newCacheManagerBuilder() 
       .with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://192.168.147.50:9510")).readOperationTimeout(500,TimeUnit.MILLISECONDS).autoCreate()); 
  
final PersistentCacheManager cacheManager =clusteredCacheManagerBuilder. build(true); 
  
  
Cache<String, String> myCache = cacheManager.createCache("myCache", 
       CacheConfigurationBuilder.newCacheConfigurationBuilder( 
               String.class, 
               String.class, 
               ResourcePoolsBuilder.newResourcePoolsBuilder().with(ClusteredResourcePoolBuilder.clusteredDedicated("cache",32, MemoryUnit.MB))) 
               .withDispatcherConcurrency(4).withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS)))); 

可以看到一個問題，此處只指定了IP為192.168.147.50這臺機器的tc-server，那么當50這臺機器掛了，目前是不能自動連接到52機器的。不知道未來是否會支持。或者考慮使用其主打產品BigMemory(付費)。

對于分布式緩存個人還是喜歡使用Redis之類的，性能也非常好，有主從模式、集群模式。目前不建議使用Ehcache3.1+Terracottaserver組合。

5. 多級緩存

如先查找堆緩存，如果沒有查找磁盤緩存，則使用MapDB可以通過如下配置實現。

HTreeMap diskCache = db.hashMap("myCache") 
       .expireStoreSize(8 * 1024 * 1024 * 1024) 
       .expireMaxSize(10000) 
       .expireAfterCreate(10, TimeUnit.SECONDS) 
       .expireAfterUpdate(10, TimeUnit.SECONDS) 
       .expireAfterGet(10, TimeUnit.SECONDS) 
       .createOrOpen(); 
  
HTreeMap heapCache = db.hashMap("myCache") 
       .expireMaxSize(100) 
       .expireAfterCreate(10, TimeUnit.SECONDS) 
       .expireAfterUpdate(10, TimeUnit.SECONDS) 
       .expireAfterGet(10, TimeUnit.SECONDS) 
       .expireOverflow(diskCache) //當緩存溢出時存儲到disk 
       .createOrOpen(); 

使用JMH時首先進行JVM預熱，然后進行度量，產生測試結果(本文使用吞吐量)。建議讀者按照需求進行基準性能測試來選擇適合自己的緩存框架。

【本文是51CTO專欄作者張開濤的原創文章，作者微信公眾號：開濤的博客( kaitao-1234567)】

戳這里，看該作者更多好文