日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
張開濤：應(yīng)用級緩存之緩存使用模式實踐—

前面已經(jīng)介紹了Java緩存的使用。對于我們來說如果有人總結(jié)一些緩存使用模式/模板的話，我們在使用時直接照著模式寫即可。而實際確實已經(jīng)有總結(jié)好的模式，主要分兩大類：Cache-Aside和Cache-As-SoR(Read-through、Write-through、Write-behind)。

在網(wǎng)站制作、成都網(wǎng)站制作中從網(wǎng)站色彩、結(jié)構(gòu)布局、欄目設(shè)置、關(guān)鍵詞群組等細微處著手，突出企業(yè)的產(chǎn)品/服務(wù)/品牌，幫助企業(yè)鎖定精準用戶，提高在線咨詢和轉(zhuǎn)化，使成都網(wǎng)站營銷成為有效果、有回報的無錫營銷推廣。創(chuàng)新互聯(lián)建站專業(yè)成都網(wǎng)站建設(shè)十年了，客戶滿意度97.8%，歡迎成都創(chuàng)新互聯(lián)客戶聯(lián)系。

首先，同步兩個名詞。

  • SoR(system-of-record)：記錄系統(tǒng)，或者可以叫做數(shù)據(jù)源，即實際存儲原始數(shù)據(jù)的系統(tǒng)。
  • Cache：緩存，是SoR的快照數(shù)據(jù)，Cache的訪問速度比SoR要快，放入Cache的目的是提升訪問速度，減少回源到SoR的次數(shù)。
  • 回源：即回到數(shù)據(jù)源頭獲取數(shù)據(jù)，Cache沒有***時，需要從SoR讀取數(shù)據(jù)，這叫做回源。

本文主要以Guava Cache和Ehcache3.x作為實踐框架來講解。

一、Cache-Aside

Cache-Aside即業(yè)務(wù)代碼圍繞著Cache寫，是由業(yè)務(wù)代碼直接維護緩存，示例代碼如下所示。

讀場景，先從緩存獲取數(shù)據(jù)，如果沒有***，則回源到SoR并將源數(shù)據(jù)放入緩存供下次讀取使用。

 
 
 
    
  
  
  
  1. //1、先從緩存中獲取數(shù)據(jù) 
    2.   
  
  
  2. value = myCache.getIfPresent(key); 
    3.   
  
  
  3. if(value == null) { 
    4.   
  
  
  4.     //2.1、如果緩存沒有***，則回源到SoR獲取源數(shù)據(jù) 
    5.   
  
  
  5.     value = loadFromSoR(key); 
    6.   
  
  
  6.     //2.2、將數(shù)據(jù)放入緩存，下次即可從緩存中獲取數(shù)據(jù) 
    7.   
  
  
  7.     myCache.put(key, value); 
    8.   
  
  
  8. } 
    9.

寫場景，先將數(shù)據(jù)寫入SoR，寫入成功后立即將數(shù)據(jù)同步寫入緩存。

 
 
 
    
  
  
  
  1. //1、先將數(shù)據(jù)寫入SoR 
    2.   
  
  
  2. writeToSoR(key,value); 
    3.   
  
  
  3. //2、執(zhí)行成功后立即同步寫入緩存 
    4.   
  
  
  4. myCache.put(key, value); 
    5.

或者先將數(shù)據(jù)寫入SoR，寫入成功后將緩存數(shù)據(jù)過期，下次讀取時再加載緩存。

 
 
 
    
  
  
  
  1. //1、先將數(shù)據(jù)寫入SoR 
    2.   
  
  
  2. writeToSoR(key,value); 
    3.   
  
  
  3. //2、失效緩存，然后下次讀時再加載緩存 
    4.   
  
  
  4. myCache.invalidate(key); 
    5.

Cache-Aside適合使用AOP模式去實現(xiàn)，可以參考筆者的博客《Spring Cache抽象詳解》去實現(xiàn)。

對于Cache-Aside可能存在并發(fā)更新情況，即如果多個應(yīng)用實例同時更新，那么緩存怎么辦?

● 如果是用戶維度的數(shù)據(jù)(如訂單數(shù)據(jù)、用戶數(shù)據(jù))，則出現(xiàn)這種幾率非常小，因為并發(fā)的情況很少，可以不考慮這個問題，加上過期時間來解決即可。

● 對于如商品這種基礎(chǔ)數(shù)據(jù)，可以考慮使用canal訂閱binlog進行增量更新分布式緩存，這樣不會存在緩存數(shù)據(jù)不一致的情況，但是，緩存更新會存在延遲。而本地緩存根據(jù)不一致容忍度設(shè)置合理的過期時間。

● 讀服務(wù)場景，可以考慮使用一致性哈希，將相同的操作負載均衡到同一個實例，從而減少并發(fā)幾率。或者設(shè)置比較短的過期時間，可參考“第17章 京東商品詳情頁服務(wù)閉環(huán)實踐”。

二、Cache-As-SoR

Cache-As-SoR即把Cache看作為SoR，所有操作都是對Cache進行，然后Cache再委托給SoR進行真實的讀/寫。即業(yè)務(wù)代碼中只看到Cache的操作，看不到關(guān)于SoR相關(guān)的代碼。有三種實現(xiàn)：read-through、write-through、write-behind。

1. Read-Through

Read-Through，業(yè)務(wù)代碼首先調(diào)用Cache，如果Cache不***由Cache回源到SoR，而不是業(yè)務(wù)代碼(即由Cache讀SoR)。使用Read-Through模式，需要配置一個CacheLoader組件用來回源到SoR加載源數(shù)據(jù)。Guava Cache和Ehcache 3.x都支持該模式。

Guava Cache實現(xiàn)

 
 
 
    
  
  
  
  1. LoadingCache> getCache = 
    2.   
  
  
  2.        CacheBuilder.newBuilder() 
    3.   
  
  
  3.                .softValues() 
    4.   
  
  
  4.                .maximumSize(5000).expireAfterWrite(2, TimeUnit.MINUTES) 
    5.   
  
  
  5.                 .build(new CacheLoader>() { 
    6.   
  
  
  6.                    @Override 
    7.   
  
  
  7.                    public Result load(final Integer sortId) throwsException { 
    8.   
  
  
  8.                         return categoryService.get(sortId); 
    9.   
  
  
  9.                    } 
    10.   
  
  
  10.                }); 
    11.

在build Cache時，傳入一個CacheLoader用來加載緩存，操作流程如下。

  • 應(yīng)用業(yè)務(wù)代碼直接調(diào)用getCache.get(sortId)。
  • 首先查詢Cache，如果緩存中有，則直接返回緩存數(shù)據(jù)。
  • 如果緩存沒有***，則委托給CacheLoader，CacheLoader會回源到SoR查詢源數(shù)據(jù)(返回值必須不為null，可以包裝為Null對象)，然后寫入緩存。

使用CacheLoader后有幾個好處。

● 應(yīng)用業(yè)務(wù)代碼更簡潔了，不需要像Cache-Aside模式那樣緩存查詢代碼和SoR代碼交織在一起。如果緩存使用邏輯散落在多處，則使用這種方式很簡單的消除了重復代碼。

● 解決Dog-pile effect，即當某個緩存失效時，又有大量相同的請求沒***緩存，從而同時請求到后端，導致后端壓力太大，此時限制一個請求去拿即可。

 
 
 
    
  
  
  
  1. if (firstCreateNewEntry) {//***個請求加載緩存的線程去SoR加載源數(shù)據(jù) 
    2.   
  
  
  2.   try { 
    3.   
  
  
  3.     synchronized (e) { 
    4.   
  
  
  4.       returnloadSync(key, hash, loadingValueReference, loader); 
    5.   
  
  
  5.     } 
    6.   
  
  
  6.   } finally{ 
    7.   
  
  
  7.     statsCounter.recordMisses(1); 
    8.   
  
  
  8.   } 
    9.   
  
  
  9. } else {//其他并發(fā)線程等待“***個線程”加載的數(shù)據(jù) 
    10.   
  
  
  10.   return waitForLoadingValue(e, key,valueReference); 
    11.   
  
  
  11. } 
    12.   
  
  
  12.  
    13.   
  
  
  13. Guava Cache還支持get(K key, Callable valueLoader)方法，傳入一個Callable實例，當緩存沒***時，會調(diào)用Callable#call來查詢SoR加載源數(shù)據(jù)。 
    14.   
  
  
  14.  
    15.   
  
  
  15. Ehcache 3.x實現(xiàn) 
    16.   
  
  
  16. CacheManager cacheManager = CacheManagerBuilder. newCacheManagerBuilder(). build(true); 
    17.   
  
  
  17. org.ehcache.Cache myCache =cacheManager. createCache ("myCache", 
    18.   
  
  
  18.        CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class, 
    19.   
  
  
  19.                ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100,MemoryUnit.MB)) 
    20.   
  
  
  20.                .withDispatcherConcurrency(4) 
    21.   
  
  
  21.                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS))) 
    22.   
  
  
  22.                 .withLoaderWriter(newDefaultCacheLoaderWriter () { 
    23.   
  
  
  23.                    @Override 
    24.   
  
  
  24.                    public String load(String key) throws Exception { 
    25.   
  
  
  25.                         return readDB(key); 
    26.   
  
  
  26.                    } 
    27.   
  
  
  27.                     @Override 
    28.   
  
  
  28.                    public Map loadAll(Iterable keys) throws BulkCacheLoadingException, Exception { 
    29.   
  
  
  29.                         return null; 
    30.   
  
  
  30.                    } 
    31.   
  
  
  31.                })); 
    32.

Ehcache 3.x使用CacheLoaderWriter來實現(xiàn)，通過load(K key)和loadAll(Iterable keys)分別來加載單個KEY和批量KEY。Ehcache 3.1沒有自己去解決Dog-pile effect。

2. Write-Through

Write-Through，稱之為穿透寫模式/直寫模式，業(yè)務(wù)代碼首先調(diào)用Cache寫(新增/修改)數(shù)據(jù)，然后由Cache負責寫緩存和寫SoR，而不是業(yè)務(wù)代碼。使用Write-Through模式需要配置一個CacheWriter組件用來回寫SoR。Guava Cache沒有提供支持。Ehcache 3.x支持該模式。Ehcache需要配置一個CacheLoaderWriter，CacheLoaderWriter知道如何去寫SoR。當Cache需要寫(新增/修改)數(shù)據(jù)時，首先調(diào)用CacheLoaderWriter來同步(立即)到SoR，成功后會更新緩存。

 
 
 
    
  
  
  
  1. CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build(true); 
    2.   
  
  
  2. org.ehcache.Cache myCache =cacheManager.createCache ("myCache", 
    3.   
  
  
  3.        CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class, 
    4.   
  
  
  4.                ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100,MemoryUnit.MB)) 
    5.   
  
  
  5.                .withDispatcherConcurrency(4) 
    6.   
  
  
  6.                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS))) 
    7.   
  
  
  7.                 .withLoaderWriter(newDefaultCacheLoaderWriter () { 
    8.   
  
  
  8.                    @Override 
    9.   
  
  
  9.                    public void write(String key, String value) throws Exception{ 
    10.   
  
  
  10.                         //write 
    11.   
  
  
  11.                    } 
    12.   
  
  
  12.                    @Override 
    13.   
  
  
  13.                    public void writeAll(Iterable> entries) throws BulkCacheWritingException,Exception { 
    14.   
  
  
  14.                         for(Object entry: entries) { 
    15.   
  
  
  15.                             //batch write 
    16.   
  
  
  16.                         } 
    17.   
  
  
  17.                    } 
    18.   
  
  
  18.                    @Override 
    19.   
  
  
  19.                     public void delete(Stringkey) throws Exception { 
    20.   
  
  
  20.                         //delete 
    21.   
  
  
  21.                    } 
    22.   
  
  
  22.                    @Override 
    23.   
  
  
  23.                    public void deleteAll(Iterablekeys) throws BulkCacheWritingException, Exception { 
    24.   
  
  
  24.                         for(Object key :keys) { 
    25.   
  
  
  25.                             //batch delete 
    26.   
  
  
  26.                         } 
    27.   
  
  
  27.                    } 
    28.   
  
  
  28.                }).build()); 
    29.

Ehcache 3.x還是使用CacheLoaderWriter來實現(xiàn)，通過write(String key, String value)、writeAll(Iterable > entries)和delete(String key)、deleteAll(Iterable keys)分別來支持單個寫、批量寫和單個刪除、批量刪除操作。

操作流程如下。

  • 當我們調(diào)用myCache.put("e","123")或者myCache.putAll(map)時，寫緩存。
  • 首先，Cache會將寫操作立即委托給CacheLoaderWriter#write和#writeAll，然后由CacheLoaderWriter負責立即去寫SoR。
  • 當寫SoR成功后，再寫入Cache。

3. Write-Behind

Write-Behind，也叫Write-Back，稱之為回寫模式，不同于Write-Through是同步寫SoR和Cache，Write-Behind是異步寫。異步之后可以實現(xiàn)批量寫、合并寫、延時和限流。

(1) 異步寫

 
 
 
    
  
  
  
  1. CacheManager cacheManager = CacheManagerBuilder. newCacheManagerBuilder() 
    2.   
  
  
  2.        .using(PooledExecutionServiceConfigurationBuilder 
    3.   
  
  
  3.                .newPooledExecutionServiceConfigurationBuilder() 
    4.   
  
  
  4.                .pool("writeBehindPool", 1, 5) 
    5.   
  
  
  5.                .build()) 
    6.   
  
  
  6.        .build(true); 
    7.   
  
  
  7. org.ehcache.Cache myCache =cacheManager. createCache ("myCache", 
    8.   
  
  
  8.        CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class, 
    9.   
  
  
  9.                ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100,MemoryUnit.MB)) 
    10.   
  
  
  10.                .withDispatcherConcurrency(4) 
    11.   
  
  
  11.                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS))) 
    12.   
  
  
  12.                 .withLoaderWriter(new DefaultCacheLoaderWriter() { 
    13.   
  
  
  13.                    @Override 
    14.   
  
  
  14.                    public void write(String key, String value) throws Exception{ 
    15.   
  
  
  15.                         //write 
    16.   
  
  
  16.                     } 
    17.   
  
  
  17.   
    18.   
  
  
  18.                    @Override 
    19.   
  
  
  19.                    public void delete(String key) throws Exception { 
    20.   
  
  
  20.                         //delete 
    21.   
  
  
  21.                     } 
    22.   
  
  
  22.                }) 
    23.   
  
  
  23.                .add(WriteBehindConfigurationBuilder 
    24.   
  
  
  24.                         .newUnBatchedWriteBehindConfiguration() 
    25.   
  
  
  25.                         .queueSize(5) 
    26.   
  
  
  26.                         .concurrencyLevel(2 
    27.   
  
  
  27.                         .useThreadPool("writeBehindPool") 
    28.   
  
  
  28.                         .build())); 
    29.

幾個重要配置如下。

  • hreadPool：使用PooledExecutionServiceConfigurationBuilder配置線程池;然后WriteBehindConfigurationBuilder通過useThreadPool配置使用哪一個線程池;
  • WriteBehindConfigurationBuilder：配置WriteBehind策略;
  • CacheLoaderWriter：配置WriteBehind如何操作SoR。

WriteBehindConfigurationBuilder會進行如下幾個配置。

  • newUnBatchedWriteBehindConfiguration：表示不進行批量處理，那么所有批量操作都將會轉(zhuǎn)換成單個操作，即CacheLoaderWriter只需要實現(xiàn)write和delete即可。
  • queueSize(int size)：因為操作是異步回寫SoR，需要將操作先放入寫操作等待隊列，因此，使用queue size定義寫操作等待隊列***大小，即線程池隊列大小。內(nèi)部使用NonBatchingLocalHeapWriteBehindQueue。
  • concurrencyLevel(int concurrency)：配置使用多少個并發(fā)線程和隊列進行WriteBehind。因為我們只傳入一個線程池，這是如何實現(xiàn)該模式的呢?首先看如下代碼片段。
    •   
  
  
      
   
   
   
    1. for (int i = 0; i < writeBehindConcurrency; i++) { 
      2.    
   
   
    2.   if (config.getBatchingConfiguration()== null) { 
      3.    
   
   
    3.     this.stripes.add(newNonBatchingLocalHeapWriteBehindQueue(executionService,defaultThreadPool, config, cacheLoaderWriter)); 
      4.    
   
   
    4.   } else { 
      5.    
   
   
    5.     this.stripes.add(newBatchingLocalHeapWriteBehindQueue(executionService, defaultThreadPool,config, cacheLoaderWriter)); 
      6.    
   
   
    6.   } 
      7.    
   
   
    7. } 
      8.

可以看到會創(chuàng)建concurrencyLevel個隊列NonBatchingLocalHeapWriteBehindQueue，其又通過如下代碼片段創(chuàng)建線程池和線程池隊列。

 
 
 
    
  
  
  
  1. this.executorQueue = new LinkedBlockingQueue(config.getMaxQueueSize()); 
    2.   
  
  
  2. if (config.getThreadPoolAlias() == null) { 
    3.   
  
  
  3.   this.executor= executionService.getOrderedExecutor(defaultThreadPool, executorQueue); 
    4.   
  
  
  4. } else { 
    5.   
  
  
  5.   this.executor= executionService.getOrderedExecutor(config. getThreadPoolAlias(), executorQueue); 
    6.   
  
  
  6. } 
    7.   
  
  
  7. ●     CacheLoaderWriter：此處我們只配置了write和delete，而writeAll和deleteAll將會把批量操作委托給write和delete。 
    8.   
  
  
  8. PooledExecutionService#getOrderedExecutor方法會創(chuàng)建PartitionedOrderedExecutor實例。 
    9.   
  
  
  9. PartitionedOrderedExecutor(BlockingQueue queue,ExecutorService executor) { 
    10.   
  
  
  10.   this.delegate= new PartitionedUnorderedExecutor(queue, executor, 1); 
    11.   
  
  
  11. } 
    12.

其使用maxWorkers=1創(chuàng)建了PartitionedUnorderedExecutor，然后Partitioned UnorderedExecutor通過this.runnerPermit = newSemaphore(maxWorkers)來控制并發(fā)，即maxWorkers=1就實現(xiàn)了一個并發(fā)。

因此，Ehcache實際能寫的***隊列大小為concurrency level *queue size。

因為內(nèi)部使用線程池去寫，因此就實現(xiàn)了異步寫，又因為使用了隊列，因此控制了總的吞吐量(此處有注意根據(jù)實際場景給線程池配置Rejected Policy)，接下來看下如何實現(xiàn)批量寫。

(2) 批量寫

 
 
 
    
  
  
  
  1. .withLoaderWriter(new DefaultCacheLoaderWriter() { 
    2.   
  
  
  2.    @Override 
    3.   
  
  
  3.     publicvoid writeAll(Iterable> entries) throws BulkCacheWritingException,Exception { 
    4.   
  
  
  4.         for(Objectentry : entries) { 
    5.   
  
  
  5.             //batchwrite 
    6.   
  
  
  6.         } 
    7.   
  
  
  7.     } 
    8.   
  
  
  8.    @Override 
    9.   
  
  
  9.     publicvoid deleteAll(Iterable keys) throws BulkCacheWritingException,Exception { 
    10.   
  
  
  10.         for(Objectkey : keys) { 
    11.   
  
  
  11.             //batchdelete 
    12.   
  
  
  12.         } 
    13.   
  
  
  13.     } 
    14.   
  
  
  14. }) 
    15.   
  
  
  15. .add(WriteBehindConfigurationBuilder 
    16.   
  
  
  16.         .newBatchedWriteBehindConfiguration(3,TimeUnit.SECONDS, 2) 
    17.   
  
  
  17.        .queueSize(5) 
    18.   
  
  
  18.        .concurrencyLevel(1) 
    19.   
  
  
  19.        .enableCoalescing() 
    20.   
  
  
  20.        .useThreadPool("writeBehindPool") 
    21.   
  
  
  21.        .build())); 
    22.

和上一個示例不同的地方是使用了newBatchedWriteBehindConfiguration進行批量配置。

● newBatchedWriteBehindConfiguration(longmaxDelay, TimeUnit maxDelayUnit, int batchSize)：設(shè)置批處理大小和***延遲。batchSize用于定義批處理大小，當寫操作數(shù)量等于批處理大小時，將把這一批數(shù)據(jù)發(fā)給CacheLoaderWriter進行處理。Ehcache使用BatchingLocalHeapWriteBehindQueue實現(xiàn)批量隊列，其中操作批量的代碼如下。

 
 
 
    
  
  
  
  1. if (openBatch.add(operation)) {//往batch里添加操作，添加的數(shù)量等于批處理大小時 
    2.   
  
  
  2.   submit(openBatch);//異步提交批處理操作 
    3.   
  
  
  3.   openBatch= null; 
    4.   
  
  
  4. } 
    5.

因此，Ehcache實際能寫的***隊列大小為concurrency level * queue size * batch size。

maxDelay用于配置未完成的批處理***延遲，比如，我們設(shè)置批處理大小為3，而我們實際只寫入了兩個數(shù)據(jù)，當寫第3個數(shù)據(jù)時，會觸發(fā)提交批處理操作。但是，如果我們不寫第3個，那么將造成這2個數(shù)據(jù)一直等待，我們可以設(shè)置maxDelay，當超時時也會將這兩個數(shù)據(jù)提交批處理。

● enableCoalescing：是否需要合并寫，即對于相同的Key只記錄***一次數(shù)據(jù)。

● CacheLoaderWriter：write和delete會轉(zhuǎn)換為writeAll和deleteAll，即批處理。

三、Copy Pattern

有兩種Copy Pattern，Copy-On-Read(在讀時復制)和Copy-On-Write(在寫時復制)，對于Guava Cache和Ehcache中堆緩存都是基于引用的，這樣如果有人拿到緩存數(shù)據(jù)并修改了它，則可能發(fā)生不可預測的問題，筆者就見過因為這種情況造成數(shù)據(jù)錯誤。Guava Cache沒有提供支持，Ehcache 3.x提供了支持。

 
 
 
    
  
  
  
  1. public interface Copier { 
    2.   
  
  
  2.   TcopyForRead(T obj); //Copy-On-Read，比如myCache.get() 
    3.   
  
  
  3.   TcopyForWrite(T obj); //Copy-On-Write，比如myCache.put() 
    4.   
  
  
  4. } 
    5.

通過如下方法來配置Key和Value的Copier。

 
 
 
    
  
  
  
  1. CacheConfigurationBuilder.withKeyCopier() 
    2.   
  
  
  2. CacheConfigurationBuilder.withValueCopier() 
    3.

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


文章標題：張開濤：應(yīng)用級緩存之緩存使用模式實踐—
網(wǎng)站路徑：http://www.5511xx.com/article/cdooeej.html