自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

張開濤：Java應用緩存示例

作者：張開濤
開發(fā) 開發(fā)工具
緩存的工作機制是先從緩存中讀取數(shù)據，如果沒有，則再從慢速設備上讀取實際數(shù)據并同步到緩存。本文以Java應用緩存為示例進行講解。

一、緩存簡介

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

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

二、緩存命中率

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

三、緩存回收策略

1. 基于空間

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

2. 基于容量

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

3. 基于時間

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

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

4. 基于Java對象引用

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

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

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

5. 回收算法

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

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

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

四、Java緩存類型

  • 堆緩存：使用Java堆內存來存儲緩存對象。使用堆緩存的好處是沒有序列化/反序列化，是最快的緩存。缺點也很明顯，當緩存的數(shù)據量很大時， GC暫停時間會變長，存儲容量受限于堆空間大小。一般通過軟引用/弱引用來存儲緩存對象，即當堆內存不足時，可以強制回收這部分內存釋放堆內存空間。一般使用堆緩存存儲較熱的數(shù)據?？梢允褂肎uava Cache、Ehcache 3.x、MapDB實現(xiàn)。
  • 堆外緩存：即緩存數(shù)據存儲在堆外內存，可以減少GC暫停時間(堆對象轉移到堆外，GC掃描和移動的對象變少了)，可以支持更大的緩存空間(只受機器內存大小限制，不受堆空間的影響)。但是，讀取數(shù)據時需要序列化/反序列化，因此，會比堆緩存慢很多?？梢允褂肊hcache 3.x、MapDB實現(xiàn)。
  • 磁盤緩存：即緩存數(shù)據的存儲在磁盤上，當JVM重啟時數(shù)據還是在的。而堆緩存/堆外緩存重啟時數(shù)據會丟失，需要重新加載。可以使用Ehcache 3.x、MapDB實現(xiàn)。
  • 分布式緩存：上文提到的緩存是進程內緩存和磁盤緩存，在多JVM實例的情況時，會存在兩個問題：1.單機容量問題;2.數(shù)據一致性問題(多臺JVM實例的緩存數(shù)據不一致怎么辦)，不過，這個問題不用太糾結，既然數(shù)據允許緩存，則表示允許一定時間內的不一致，因此，可以設置緩存數(shù)據的過期時間來定期更新數(shù)據;3.緩存不命中時，需要回源到DB/服務查詢變多：每個實例在緩存不命中情況下都會回源到DB加載數(shù)據，因此，多實例后DB整體的訪問量就變多了，解決辦法可以使用如一致性哈希分片算法來解決。因此，這些情況可以考慮使用分布式緩存來解決?？梢允褂胑hcache-clustered(配合Terracotta server)實現(xiàn)Java進程間分布式緩存。當然也可以使用如Redis實現(xiàn)分布式緩存。

Redis實現(xiàn)分布式緩存

兩種模式如下。

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

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

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

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

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

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

1. 堆緩存

Gauva Cache實現(xiàn)

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

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

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

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

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

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

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

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

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

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

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

(5) 并發(fā)級別

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

(6) 統(tǒng)計命中率

recordStats：啟動記錄統(tǒng)計信息，比如命中率等。

(7) EhCache 3.x實現(xiàn)

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

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

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

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

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

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

heap(100, MemoryUnit.MB)：設置緩存的內存空間，當超出此空間時按照LRU進行緩存回收。另外，應該設置withSizeOfMaxObjectGraph(2)：統(tǒng)計對象大小時對象圖遍歷深度和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()：主動失效某些緩存數(shù)據。

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

(12) 并發(fā)級別

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

(13) 統(tǒng)計命中率

目前還沒有開放API來統(tǒng)計。

MapDB 3.x實現(xiàn)

  1. HTreeMap myCache = 
  2.        DBMaker.heapDB().concurrencyScale(16).make().hashMap("myCache") 
  3.        .expireMaxSize(10000) 
  4.        .expireAfterCreate(10, TimeUnit.SECONDS) 
  5.         .expireAfterUpdate(10,TimeUnit.SECONDS) 
  6.        .expireAfterGet(10, TimeUnit.SECONDS) 
  7.        .create(); 

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

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

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

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

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

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

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

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

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

  1. .expireExecutor(scheduledExecutorService) 
  2. .expireExecutorPeriod(3000) 

d. 并發(fā)級別

concurrencyScale：類似于Guava Cache配置。

e. 統(tǒng)計命中率

暫無。

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

2. 堆外緩存

EhCache 3.x實現(xiàn)

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

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

MapDB 3.x實現(xiàn)

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

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

3. 磁盤緩存

EhCache 3.x實現(xiàn)

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

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

MapDB 3.x實現(xiàn)

  1. DB db = DBMaker 
  2.         .fileDB("D:\\bak\\a.data")//數(shù)據存哪里 
  3.         .fileMmapEnable() //啟用mmap 
  4.         .fileMmapEnableIfSupported() //在支持的平臺上啟用mmap 
  5.         .fileMmapPreclearDisable() //讓mmap文件更快 
  6.         .cleanerHackEnable() //一些BUG處理 
  7.         .transactionEnable() //啟用事務 
  8.         .closeOnJvmShutdown() 
  9.        .concurrencyScale(16) 
  10.        .make(); 
  11.   
  12. HTreeMap myCache = db.hashMap("myCache") 
  13.        .expireMaxSize(10000) 
  14.        .expireAfterCreate(10, TimeUnit.SECONDS) 
  15.        .expireAfterUpdate(10, TimeUnit.SECONDS) 
  16.        .expireAfterGet(10, TimeUnit.SECONDS) 
  17.        .createOrOpen(); 

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

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

4. 分布式緩存

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

Ehcache 3.1+Terracottaserver

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

(1) 架構

Terracotta Server配置

Terracotta Server配置

  1. <?xml version="1.0"encoding="UTF-8"?> 
  2. <tc-configxmlnstc-configxmlns="http://www.terracotta.org/config" 
  3.           xmlns:ohr="http://www.terracotta.org/config/offheap-resource"> 
  4.   
  5.  <servers> 
  6.     <server host="192.168.147.50" name="s1"> 
  7.      <tsa-port>9510</tsa-port> 
  8.      <tsa-group-port>9530</tsa-group-port> 
  9.    </server> 
  10.   
  11.     <server host="192.168.147.52" name="s2"> 
  12.      <tsa-port>9510</tsa-port> 
  13.      <tsa-group-port>9530</tsa-group-port> 
  14.    </server> 
  15.   
  16.   <client-reconnect-window>30</client-reconnect-window> 
  17.   <restartable enabled="true"/> 
  18.    </servers> 
  19.   
  20.    <services> 
  21.        <service id="resources"> 
  22.            <ohr:offheap-resources> 
  23.                <ohr:resource name="cache"unit="MB">64</ohr:resource> 
  24.            </ohr:offheap-resources> 
  25.        </service> 
  26.    </services> 
  27. </tc-config> 

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

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

(2) EhCache代碼片段

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

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

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

5. 多級緩存

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

  1. HTreeMap diskCache = db.hashMap("myCache") 
  2.        .expireStoreSize(8 * 1024 * 1024 * 1024) 
  3.        .expireMaxSize(10000) 
  4.        .expireAfterCreate(10, TimeUnit.SECONDS) 
  5.        .expireAfterUpdate(10, TimeUnit.SECONDS) 
  6.        .expireAfterGet(10, TimeUnit.SECONDS) 
  7.        .createOrOpen(); 
  8.   
  9. HTreeMap heapCache = db.hashMap("myCache") 
  10.        .expireMaxSize(100) 
  11.        .expireAfterCreate(10, TimeUnit.SECONDS) 
  12.        .expireAfterUpdate(10, TimeUnit.SECONDS) 
  13.        .expireAfterGet(10, TimeUnit.SECONDS) 
  14.        .expireOverflow(diskCache) //當緩存溢出時存儲到disk 
  15.        .createOrOpen(); 

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

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

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

責任編輯：趙寧寧 來源： 51CTO專欄
Java緩存分布式
相關推薦

2017-04-21 08:51:42

API緩存分布式

2017-05-05 10:13:03

應用級緩存緩存代碼

2017-05-10 11:40:29

緩存Nginx HTTP

2017-05-18 16:07:23

回滾數(shù)據庫代碼

2017-04-18 14:49:38

應用層API代碼

2017-06-16 15:16:15

2017-06-04 16:24:27

線程線程池中斷

2017-07-02 16:50:21

2012-12-13 17:38:48

2012年度IT博客大IT博客大賽博客

2010-06-02 17:46:54

MySQL 查詢緩存

2009-09-21 16:14:50

2016-01-04 15:16:01

京東詳情頁實踐

2018-02-08 18:00:49

Spark文件測試

2009-09-02 09:12:55

Google云計算

2010-11-29 10:53:14

Sybase日期函數(shù)

2009-07-09 16:22:12

WebWork配置

2020-09-24 11:38:52

Java開發(fā)代碼

2021-07-20 10:59:22

云計算架構示例云應用

2022-02-28 15:44:05

鴻蒙系統(tǒng)鴻蒙API加載網絡圖片

2015-01-04 13:56:44

DockerPostgreSQL
點贊
收藏

51CTO技術棧公眾號