张开涛：应用级缓存之缓存使用模式实践—

前面已经介绍了Java缓存的使用。对于我们来说如果有人总结一些缓存使用模式/模板的话，我们在使用时直接照着模式写即可。而实际确实已经有总结好的模式，主要分两大类：Cache-Aside和Cache-As-SoR(Read-through、Write-through、Write-behind)。

在网站制作、成都网站制作中从网站色彩、结构布局、栏目设置、关键词群组等细微处着手，突出企业的产品/服务/品牌，帮助企业锁定精准用户，提高在线咨询和转化，使成都网站营销成为有效果、有回报的无锡营销推广。创新互联建站专业成都网站建设十年了，客户满意度97.8%，欢迎成都创新互联客户联系。

首先，同步两个名词。

SoR(system-of-record)：记录系统，或者可以叫做数据源，即实际存储原始数据的系统。
Cache：缓存，是SoR的快照数据，Cache的访问速度比SoR要快，放入Cache的目的是提升访问速度，减少回源到SoR的次数。
回源：即回到数据源头获取数据，Cache没有***时，需要从SoR读取数据，这叫做回源。

本文主要以Guava Cache和Ehcache3.x作为实践框架来讲解。

一、Cache-Aside

Cache-Aside即业务代码围绕着Cache写，是由业务代码直接维护缓存，示例代码如下所示。

读场景，先从缓存获取数据，如果没有***，则回源到SoR并将源数据放入缓存供下次读取使用。

 
 
 
  
  
  //1、先从缓存中获取数据   
  
  value = myCache.getIfPresent(key);   
  
  if(value == null) {   
  
      //2.1、如果缓存没有***，则回源到SoR获取源数据   
  
      value = loadFromSoR(key);   
  
      //2.2、将数据放入缓存，下次即可从缓存中获取数据   
  
      myCache.put(key, value);   
  
  }

写场景，先将数据写入SoR，写入成功后立即将数据同步写入缓存。

 
 
 
  
  
  //1、先将数据写入SoR   
  
  writeToSoR(key,value);   
  
  //2、执行成功后立即同步写入缓存   
  
  myCache.put(key, value);

或者先将数据写入SoR，写入成功后将缓存数据过期，下次读取时再加载缓存。

 
 
 
  
  
  //1、先将数据写入SoR   
  
  writeToSoR(key,value);   
  
  //2、失效缓存，然后下次读时再加载缓存   
  
  myCache.invalidate(key);

Cache-Aside适合使用AOP模式去实现，可以参考笔者的博客《Spring Cache抽象详解》去实现。

对于Cache-Aside可能存在并发更新情况，即如果多个应用实例同时更新，那么缓存怎么办?

● 如果是用户维度的数据(如订单数据、用户数据)，则出现这种几率非常小，因为并发的情况很少，可以不考虑这个问题，加上过期时间来解决即可。

● 对于如商品这种基础数据，可以考虑使用canal订阅binlog进行增量更新分布式缓存，这样不会存在缓存数据不一致的情况，但是，缓存更新会存在延迟。而本地缓存根据不一致容忍度设置合理的过期时间。

● 读服务场景，可以考虑使用一致性哈希，将相同的操作负载均衡到同一个实例，从而减少并发几率。或者设置比较短的过期时间，可参考“第17章京东商品详情页服务闭环实践”。

二、Cache-As-SoR

Cache-As-SoR即把Cache看作为SoR，所有操作都是对Cache进行，然后Cache再委托给SoR进行真实的读/写。即业务代码中只看到Cache的操作，看不到关于SoR相关的代码。有三种实现：read-through、write-through、write-behind。

1. Read-Through

Read-Through，业务代码首先调用Cache，如果Cache不***由Cache回源到SoR，而不是业务代码(即由Cache读SoR)。使用Read-Through模式，需要配置一个CacheLoader组件用来回源到SoR加载源数据。Guava Cache和Ehcache 3.x都支持该模式。

Guava Cache实现

 
 
 
  
  
  LoadingCache> getCache =   
  
         CacheBuilder.newBuilder()   
  
                 .softValues()   
  
                 .maximumSize(5000).expireAfterWrite(2, TimeUnit.MINUTES)   
  
                  .build(new CacheLoader>() {   
  
                     @Override   
  
                     public Result load(final Integer sortId) throwsException {   
  
                          return categoryService.get(sortId);   
  
                     }   
  
                 });

在build Cache时，传入一个CacheLoader用来加载缓存，操作流程如下。

应用业务代码直接调用getCache.get(sortId)。
首先查询Cache，如果缓存中有，则直接返回缓存数据。
如果缓存没有***，则委托给CacheLoader，CacheLoader会回源到SoR查询源数据(返回值必须不为null，可以包装为Null对象)，然后写入缓存。

使用CacheLoader后有几个好处。

● 应用业务代码更简洁了，不需要像Cache-Aside模式那样缓存查询代码和SoR代码交织在一起。如果缓存使用逻辑散落在多处，则使用这种方式很简单的消除了重复代码。

● 解决Dog-pile effect，即当某个缓存失效时，又有大量相同的请求没***缓存，从而同时请求到后端，导致后端压力太大，此时限制一个请求去拿即可。

 
 
 
  
  
  if (firstCreateNewEntry) {//***个请求加载缓存的线程去SoR加载源数据   
  
    try {   
  
      synchronized (e) {   
  
        returnloadSync(key, hash, loadingValueReference, loader);   
  
      }   
  
    } finally{   
  
      statsCounter.recordMisses(1);   
  
    }   
  
  } else {//其他并发线程等待“***个线程”加载的数据   
  
    return waitForLoadingValue(e, key,valueReference);   
  
  }   
  
     
  
  Guava Cache还支持get(K key, Callable valueLoader)方法，传入一个Callable实例，当缓存没***时，会调用Callable#call来查询SoR加载源数据。   
  
     
  
  Ehcache 3.x实现   
  
  CacheManager cacheManager = CacheManagerBuilder. newCacheManagerBuilder(). build(true);   
  
  org.ehcache.Cache myCache =cacheManager. createCache ("myCache",   
  
         CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,   
  
                 ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100,MemoryUnit.MB))   
  
                 .withDispatcherConcurrency(4)   
  
                 .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS)))   
  
                  .withLoaderWriter(newDefaultCacheLoaderWriter () {   
  
                     @Override   
  
                     public String load(String key) throws Exception {   
  
                          return readDB(key);   
  
                     }   
  
                      @Override   
  
                     public Map loadAll(Iterable keys) throws BulkCacheLoadingException, Exception {   
  
                          return null;   
  
                     }   
  
                 }));

Ehcache 3.x使用CacheLoaderWriter来实现，通过load(K key)和loadAll(Iterable keys)分别来加载单个KEY和批量KEY。Ehcache 3.1没有自己去解决Dog-pile effect。

2. Write-Through

Write-Through，称之为穿透写模式/直写模式，业务代码首先调用Cache写(新增/修改)数据，然后由Cache负责写缓存和写SoR，而不是业务代码。使用Write-Through模式需要配置一个CacheWriter组件用来回写SoR。Guava Cache没有提供支持。Ehcache 3.x支持该模式。Ehcache需要配置一个CacheLoaderWriter，CacheLoaderWriter知道如何去写SoR。当Cache需要写(新增/修改)数据时，首先调用CacheLoaderWriter来同步(立即)到SoR，成功后会更新缓存。

 
 
 
  
  
  CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build(true);   
  
  org.ehcache.Cache myCache =cacheManager.createCache ("myCache",   
  
         CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,   
  
                 ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100,MemoryUnit.MB))   
  
                 .withDispatcherConcurrency(4)   
  
                 .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS)))   
  
                  .withLoaderWriter(newDefaultCacheLoaderWriter () {   
  
                     @Override   
  
                     public void write(String key, String value) throws Exception{   
  
                          //write   
  
                     }   
  
                     @Override   
  
                     public void writeAll(Iterable> entries) throws BulkCacheWritingException,Exception {   
  
                          for(Object entry: entries) {   
  
                              //batch write   
  
                          }   
  
                     }   
  
                     @Override   
  
                      public void delete(Stringkey) throws Exception {   
  
                          //delete   
  
                     }   
  
                     @Override   
  
                     public void deleteAll(Iterablekeys) throws BulkCacheWritingException, Exception {   
  
                          for(Object key :keys) {   
  
                              //batch delete   
  
                          }   
  
                     }   
  
                 }).build());

Ehcache 3.x还是使用CacheLoaderWriter来实现，通过write(String key, String value)、writeAll(Iterable > entries)和delete(String key)、deleteAll(Iterable keys)分别来支持单个写、批量写和单个删除、批量删除操作。

操作流程如下。

当我们调用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是异步写。异步之后可以实现批量写、合并写、延时和限流。

(1) 异步写

 
 
 
  
  
  CacheManager cacheManager = CacheManagerBuilder. newCacheManagerBuilder()   
  
         .using(PooledExecutionServiceConfigurationBuilder   
  
                 .newPooledExecutionServiceConfigurationBuilder()   
  
                 .pool("writeBehindPool", 1, 5)   
  
                 .build())   
  
         .build(true);   
  
  org.ehcache.Cache myCache =cacheManager. createCache ("myCache",   
  
         CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,   
  
                 ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100,MemoryUnit.MB))   
  
                 .withDispatcherConcurrency(4)   
  
                 .withExpiry(Expirations.timeToLiveExpiration(Duration.of(10,TimeUnit.SECONDS)))   
  
                  .withLoaderWriter(new DefaultCacheLoaderWriter() {   
  
                     @Override   
  
                     public void write(String key, String value) throws Exception{   
  
                          //write   
  
                      }   
  
      
  
                     @Override   
  
                     public void delete(String key) throws Exception {   
  
                          //delete   
  
                      }   
  
                 })   
  
                 .add(WriteBehindConfigurationBuilder   
  
                          .newUnBatchedWriteBehindConfiguration()   
  
                          .queueSize(5)   
  
                          .concurrencyLevel(2   
  
                          .useThreadPool("writeBehindPool")   
  
                          .build()));

几个重要配置如下。

hreadPool：使用PooledExecutionServiceConfigurationBuilder配置线程池;然后WriteBehindConfigurationBuilder通过useThreadPool配置使用哪一个线程池;
WriteBehindConfigurationBuilder：配置WriteBehind策略;
CacheLoaderWriter：配置WriteBehind如何操作SoR。

WriteBehindConfigurationBuilder会进行如下几个配置。

newUnBatchedWriteBehindConfiguration：表示不进行批量处理，那么所有批量操作都将会转换成单个操作，即CacheLoaderWriter只需要实现write和delete即可。
queueSize(int size)：因为操作是异步回写SoR，需要将操作先放入写操作等待队列，因此，使用queue size定义写操作等待队列***大小，即线程池队列大小。内部使用NonBatchingLocalHeapWriteBehindQueue。
concurrencyLevel(int concurrency)：配置使用多少个并发线程和队列进行WriteBehind。因为我们只传入一个线程池，这是如何实现该模式的呢?首先看如下代码片段。

  
  
  
   
   
   for (int i = 0; i < writeBehindConcurrency; i++) {    
   
     if (config.getBatchingConfiguration()== null) {    
   
       this.stripes.add(newNonBatchingLocalHeapWriteBehindQueue(executionService,defaultThreadPool, config, cacheLoaderWriter));    
   
     } else {    
   
       this.stripes.add(newBatchingLocalHeapWriteBehindQueue(executionService, defaultThreadPool,config, cacheLoaderWriter));    
   
     }    
   
   }

可以看到会创建concurrencyLevel个队列NonBatchingLocalHeapWriteBehindQueue，其又通过如下代码片段创建线程池和线程池队列。

 
 
 
  
  
  this.executorQueue = new LinkedBlockingQueue(config.getMaxQueueSize());   
  
  if (config.getThreadPoolAlias() == null) {   
  
    this.executor= executionService.getOrderedExecutor(defaultThreadPool, executorQueue);   
  
  } else {   
  
    this.executor= executionService.getOrderedExecutor(config. getThreadPoolAlias(), executorQueue);   
  
  }   
  
  ●     CacheLoaderWriter：此处我们只配置了write和delete，而writeAll和deleteAll将会把批量操作委托给write和delete。   
  
  PooledExecutionService#getOrderedExecutor方法会创建PartitionedOrderedExecutor实例。   
  
  PartitionedOrderedExecutor(BlockingQueue queue,ExecutorService executor) {   
  
    this.delegate= new PartitionedUnorderedExecutor(queue, executor, 1);   
  
  }

其使用maxWorkers=1创建了PartitionedUnorderedExecutor，然后Partitioned UnorderedExecutor通过this.runnerPermit = newSemaphore(maxWorkers)来控制并发，即maxWorkers=1就实现了一个并发。

因此，Ehcache实际能写的***队列大小为concurrency level *queue size。

因为内部使用线程池去写，因此就实现了异步写，又因为使用了队列，因此控制了总的吞吐量(此处有注意根据实际场景给线程池配置Rejected Policy)，接下来看下如何实现批量写。

(2) 批量写

 
 
 
  
  
  .withLoaderWriter(new DefaultCacheLoaderWriter() {   
  
     @Override   
  
      publicvoid writeAll(Iterable> entries) throws BulkCacheWritingException,Exception {   
  
          for(Objectentry : entries) {   
  
              //batchwrite   
  
          }   
  
      }   
  
     @Override   
  
      publicvoid deleteAll(Iterable keys) throws BulkCacheWritingException,Exception {   
  
          for(Objectkey : keys) {   
  
              //batchdelete   
  
          }   
  
      }   
  
  })   
  
  .add(WriteBehindConfigurationBuilder   
  
          .newBatchedWriteBehindConfiguration(3,TimeUnit.SECONDS, 2)   
  
         .queueSize(5)   
  
         .concurrencyLevel(1)   
  
         .enableCoalescing()   
  
         .useThreadPool("writeBehindPool")   
  
         .build()));

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

● newBatchedWriteBehindConfiguration(longmaxDelay, TimeUnit maxDelayUnit, int batchSize)：设置批处理大小和***延迟。batchSize用于定义批处理大小，当写操作数量等于批处理大小时，将把这一批数据发给CacheLoaderWriter进行处理。Ehcache使用BatchingLocalHeapWriteBehindQueue实现批量队列，其中操作批量的代码如下。

 
 
 
  
  
  if (openBatch.add(operation)) {//往batch里添加操作，添加的数量等于批处理大小时   
  
    submit(openBatch);//异步提交批处理操作   
  
    openBatch= null;   
  
  }

因此，Ehcache实际能写的***队列大小为concurrency level * queue size * batch size。

maxDelay用于配置未完成的批处理***延迟，比如，我们设置批处理大小为3，而我们实际只写入了两个数据，当写第3个数据时，会触发提交批处理操作。但是，如果我们不写第3个，那么将造成这2个数据一直等待，我们可以设置maxDelay，当超时时也会将这两个数据提交批处理。

● enableCoalescing：是否需要合并写，即对于相同的Key只记录***一次数据。

● CacheLoaderWriter：write和delete会转换为writeAll和deleteAll，即批处理。

三、Copy Pattern

有两种Copy Pattern，Copy-On-Read(在读时复制)和Copy-On-Write(在写时复制)，对于Guava Cache和Ehcache中堆缓存都是基于引用的，这样如果有人拿到缓存数据并修改了它，则可能发生不可预测的问题，笔者就见过因为这种情况造成数据错误。Guava Cache没有提供支持，Ehcache 3.x提供了支持。

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

通过如下方法来配置Key和Value的Copier。

 
 
 
  
  
  CacheConfigurationBuilder.withKeyCopier()   
  
  CacheConfigurationBuilder.withValueCopier()

【本文是专栏作者张开涛的原创文章，作者微信公众号：开涛的博客( kaitao-1234567)】

本文标题：张开涛：应用级缓存之缓存使用模式实践—
转载源于：http://www.csdahua.cn/qtweb/news19/82169.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：快上网

成都快上网为您推荐相关内容