东南亚购物网站排名,取消wordpress还原,建网站需要什么东西,seo优化专员编辑这一篇我们将要谈到一个新的本地缓存框架#xff1a;Caffeine Cache。它也是站在巨人的肩膀上-Guava Cache#xff0c;借着他的思想优化了算法发展而来。
本篇博文主要介绍Caffine Cache 的使用方式#xff0c;以及Caffine Cache在SpringBoot中的使用。 1. Caffine Cache 在…这一篇我们将要谈到一个新的本地缓存框架Caffeine Cache。它也是站在巨人的肩膀上-Guava Cache借着他的思想优化了算法发展而来。
本篇博文主要介绍Caffine Cache 的使用方式以及Caffine Cache在SpringBoot中的使用。 1. Caffine Cache 在算法上的优点-W-TinyLFU
说到优化Caffine Cache到底优化了什么呢我们刚提到过LRU常见的缓存淘汰算法还有FIFOLFU FIFO先进先出在这种淘汰算法中先进入缓存的会先被淘汰会导致命中率很低。 LRU最近最少使用算法每次访问数据都会将其放在我们的队尾如果需要淘汰数据就只需要淘汰队首即可。仍然有个问题如果有个数据在 1 分钟访问了 1000次再后 1 分钟没有访问这个数据但是有其他的数据访问就导致了我们这个热点数据被淘汰。 LFU最近最少频率使用利用额外的空间记录每个数据的使用频率然后选出频率最低进行淘汰。这样就避免了 LRU 不能处理时间段的问题。
上面三种策略各有利弊实现的成本也是一个比一个高同时命中率也是一个比一个好。Guava Cache虽然有这么多的功能但是本质上还是对LRU的封装如果有更优良的算法并且也能提供这么多功能相比之下就相形见绌了。
LFU的局限性在 LFU 中只要数据访问模式的概率分布随时间保持不变时其命中率就能变得非常高。比如有部新剧出来了我们使用 LFU 给他缓存下来这部新剧在这几天大概访问了几亿次这个访问频率也在我们的 LFU 中记录了几亿次。但是新剧总会过气的比如一个月之后这个新剧的前几集其实已经过气了但是他的访问量的确是太高了其他的电视剧根本无法淘汰这个新剧所以在这种模式下是有局限性。
LRU的优点和局限性LRU可以很好的应对突发流量的情况因为他不需要累计数据频率。但LRU通过历史数据来预测未来是局限的它会认为最后到来的数据是最可能被再次访问的从而给与它最高的优先级。
在现有算法的局限性下会导致缓存数据的命中率或多或少的受损而命中略又是缓存的重要指标。HighScalability网站刊登了一篇文章由前Google工程师发明的W-TinyLFU——一种现代的缓存 。Caffine Cache就是基于此算法而研发。Caffeine 因使用 Window TinyLfu 回收策略提供了一个近乎最佳的命中率。 当数据的访问模式不随时间变化的时候LFU的策略能够带来最佳的缓存命中率。然而LFU有两个缺点 首先它需要给每个记录项维护频率信息每次访问都需要更新这是个巨大的开销 其次如果数据访问模式随时间有变LFU的频率信息无法随之变化因此早先频繁访问的记录可能会占据缓存而后期访问较多的记录则无法被命中。 因此大多数的缓存设计都是基于LRU或者其变种来进行的。相比之下LRU并不需要维护昂贵的缓存记录元信息同时也能够反应随时间变化的数据访问模式。然而在许多负载之下LRU依然需要更多的空间才能做到跟LFU一致的缓存命中率。因此一个“现代”的缓存应当能够综合两者的长处。 TinyLFU维护了近期访问记录的频率信息作为一个过滤器当新记录来时只有满足TinyLFU要求的记录才可以被插入缓存。如前所述作为现代的缓存它需要解决两个挑战
一个是如何避免维护频率信息的高开销
另一个是如何反应随时间变化的访问模式。
首先来看前者TinyLFU借助了数据流Sketching技术Count-Min Sketch显然是解决这个问题的有效手段它可以用小得多的空间存放频率信息而保证很低的False Positive Rate。但考虑到第二个问题就要复杂许多了因为我们知道任何Sketching数据结构如果要反应时间变化都是一件困难的事情在Bloom Filter方面我们可以有Timing Bloom Filter但对于CMSketch来说如何做到Timing CMSketch就不那么容易了。TinyLFU采用了一种基于滑动窗口的时间衰减设计机制借助于一种简易的reset操作每次添加一条记录到Sketch的时候都会给一个计数器上加1当计数器达到一个尺寸W的时候把所有记录的Sketch数值都除以2该reset操作可以起到衰减的作用 。
W-TinyLFU主要用来解决一些稀疏的突发访问元素。在一些数目很少但突发访问量很大的场景下TinyLFU将无法保存这类元素因为它们无法在给定时间内积累到足够高的频率。因此W-TinyLFU就是结合LFU和LRU前者用来应对大多数场景而LRU用来处理突发流量。
在处理频率记录的方案中你可能会想到用hashMap去存储每一个key对应一个频率值。那如果数据量特别大的时候是不是这个hashMap也会特别大呢。由此可以联想到 Bloom Filter对于每个key用n个byte每个存储一个标志用来判断key是否在集合中。原理就是使用k个hash函数来将key散列成一个整数。
在W-TinyLFU中使用Count-Min Sketch记录我们的访问频率而这个也是布隆过滤器的一种变种。如下图所示: 如果需要记录一个值那我们需要通过多种Hash算法对其进行处理hash然后在对应的hash算法的记录中1为什么需要多种hash算法呢由于这是一个压缩算法必定会出现冲突比如我们建立一个byte的数组通过计算出每个数据的hash的位置。比如张三和李四他们两有可能hash值都是相同比如都是1那byte[1]这个位置就会增加相应的频率张三访问1万次李四访问1次那byte[1]这个位置就是1万零1如果取李四的访问评率的时候就会取出是1万零1但是李四命名只访问了1次啊为了解决这个问题所以用了多个hash算法可以理解为long[][]二维数组的一个概念比如在第一个算法张三和李四冲突了但是在第二个第三个中很大的概率不冲突比如一个算法大概有1%的概率冲突那四个算法一起冲突的概率是1%的四次方。通过这个模式我们取李四的访问率的时候取所有算法中李四访问最低频率的次数。所以他的名字叫Count-Min Sketch。 2. 使用
Caffeine Cache 的github地址 https://github.com/ben-manes/caffeine 目前的最新版本是
dependencygroupIdcom.github.ben-manes.caffeine/groupIdartifactIdcaffeine/artifactIdversion2.6.2/version
/dependency2.1 缓存填充策略
Caffeine Cache提供了三种缓存填充策略手动、同步加载和异步加载。
1.手动加载
在每次get key的时候指定一个同步的函数如果key不存在就调用这个函数生成一个值。
/*** 手动加载* param key* return*/
public Object manulOperator(String key) {CacheString, Object cache Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.SECONDS).expireAfterAccess(1, TimeUnit.SECONDS).maximumSize(10).build();//如果一个key不存在那么会进入指定的函数生成valueObject value cache.get(key, t - setValue(key).apply(key));cache.put(hello,value);//判断是否存在如果不存返回nullObject ifPresent cache.getIfPresent(key);//移除一个keycache.invalidate(key);return value;
}public FunctionString, Object setValue(String key){return t - key value;
}2. 同步加载
构造Cache时候build方法传入一个CacheLoader实现类。实现load方法通过key加载value。
/*** 同步加载* param key* return*/
public Object syncOperator(String key){LoadingCacheString, Object cache Caffeine.newBuilder().maximumSize(100).expireAfterWrite(1, TimeUnit.MINUTES).build(k - setValue(key).apply(key));return cache.get(key);
}public FunctionString, Object setValue(String key){return t - key value;
}3. 异步加载
AsyncLoadingCache是继承自LoadingCache类的异步加载使用Executor去调用方法并返回一个CompletableFuture。异步加载缓存使用了响应式编程模型。
如果要以同步方式调用时应提供CacheLoader。要以异步表示时应该提供一个AsyncCacheLoader并返回一个CompletableFuture。 /*** 异步加载** param key* return*/
public Object asyncOperator(String key){AsyncLoadingCacheString, Object cache Caffeine.newBuilder().maximumSize(100).expireAfterWrite(1, TimeUnit.MINUTES).buildAsync(k - setAsyncValue(key).get());return cache.get(key);
}public CompletableFutureObject setAsyncValue(String key){return CompletableFuture.supplyAsync(() - {return key value;});
}2.2 回收策略
Caffeine提供了3种回收策略基于大小回收基于时间回收基于引用回收。
1. 基于大小的过期方式
基于大小的回收策略有两种方式一种是基于缓存大小一种是基于权重。
// 根据缓存的计数进行驱逐
LoadingCacheString, Object cache Caffeine.newBuilder().maximumSize(10000).build(key - function(key));// 根据缓存的权重来进行驱逐权重只是用于确定缓存大小不会用于决定该缓存是否被驱逐
LoadingCacheString, Object cache1 Caffeine.newBuilder().maximumWeight(10000).weigher(key - function1(key)).build(key - function(key));maximumWeight与maximumSize不可以同时使用。
2.基于时间的过期方式
// 基于固定的到期策略进行退出
LoadingCacheString, Object cache Caffeine.newBuilder().expireAfterAccess(5, TimeUnit.MINUTES).build(key - function(key));
LoadingCacheString, Object cache1 Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).build(key - function(key));// 基于不同的到期策略进行退出
LoadingCacheString, Object cache2 Caffeine.newBuilder().expireAfter(new ExpiryString, Object() {Overridepublic long expireAfterCreate(String key, Object value, long currentTime) {return TimeUnit.SECONDS.toNanos(seconds);}Overridepublic long expireAfterUpdate(Nonnull String s, Nonnull Object o, long l, long l1) {return 0;}Overridepublic long expireAfterRead(Nonnull String s, Nonnull Object o, long l, long l1) {return 0;}}).build(key - function(key));Caffeine提供了三种定时驱逐策略
expireAfterAccess(long, TimeUnit)在最后一次访问或者写入后开始计时在指定的时间后过期。假如一直有请求访问该key那么这个缓存将一直不会过期。
expireAfterWrite(long, TimeUnit)在最后一次写入缓存后开始计时在指定的时间后过期。
expireAfter(Expiry)自定义策略过期时间由Expiry实现独自计算。缓存的删除策略使用的是惰性删除和定时删除。这两个删除策略的时间复杂度都是O(1)。
3. 基于引用的过期方式
Java中四种引用类型
引用类型被垃圾回收时间用途生存时间强引用 Strong Reference从来不会对象的一般状态JVM停止运行时终止软引用 Soft Reference在内存不足时对象缓存内存不足时终止弱引用 Weak Reference在垃圾回收时对象缓存gc运行后终止虚引用 Phantom Reference从来不会可以用虚引用来跟踪对象被垃圾回收器回收的活动当一个虚引用关联的对象被垃圾收集器回收之前会收到一条系统通知JVM停止运行时终止
// 当key和value都没有引用时驱逐缓存
LoadingCacheString, Object cache Caffeine.newBuilder().weakKeys().weakValues().build(key - function(key));// 当垃圾收集器需要释放内存时驱逐
LoadingCacheString, Object cache1 Caffeine.newBuilder().softValues().build(key - function(key));注意AsyncLoadingCache不支持弱引用和软引用。
Caffeine.weakKeys()使用弱引用存储key。如果没有其他地方对该key有强引用那么该缓存就会被垃圾回收器回收。由于垃圾回收器只依赖于身份(identity)相等因此这会导致整个缓存使用身份 () 相等来比较 key而不是使用 equals()。
Caffeine.weakValues() 使用弱引用存储value。如果没有其他地方对该value有强引用那么该缓存就会被垃圾回收器回收。由于垃圾回收器只依赖于身份(identity)相等因此这会导致整个缓存使用身份 () 相等来比较 key而不是使用 equals()。
Caffeine.softValues() 使用软引用存储value。当内存满了过后软引用的对象以将使用最近最少使用(least-recently-used ) 的方式进行垃圾回收。由于使用软引用是需要等到内存满了才进行回收所以我们通常建议给缓存配置一个使用内存的最大值。softValues() 将使用身份相等(identity) () 而不是equals() 来比较值。
Caffeine.weakValues()和Caffeine.softValues()不可以一起使用。
3. 移除事件监听
CacheString, Object cache Caffeine.newBuilder().removalListener((String key, Object value, RemovalCause cause) -System.out.printf(Key %s was removed (%s)%n, key, cause)).build();4. 写入外部存储
CacheWriter 方法可以将缓存中所有的数据写入到第三方。
LoadingCacheString, Object cache2 Caffeine.newBuilder().writer(new CacheWriterString, Object() {Override public void write(String key, Object value) {// 写入到外部存储}Override public void delete(String key, Object value, RemovalCause cause) {// 删除外部存储}}).build(key - function(key));如果你有多级缓存的情况下这个方法还是很实用。
注意CacheWriter不能与弱键或AsyncLoadingCache一起使用。
5. 统计
与Guava Cache的统计一样。
CacheString, Object cache Caffeine.newBuilder().maximumSize(10_000).recordStats().build();通过使用Caffeine.recordStats(), 可以转化成一个统计的集合. 通过 Cache.stats() 返回一个CacheStats。CacheStats提供以下统计方法
hitRate(): 返回缓存命中率evictionCount(): 缓存回收数量averageLoadPenalty(): 加载新值的平均时间3. SpringBoot 中默认Cache-Caffine Cache
SpringBoot 1.x版本中的默认本地cache是Guava Cache。在2.xSpring Boot 2.0(spring 5) 版本中已经用Caffine Cache取代了Guava Cache。毕竟有了更优的缓存淘汰策略。
下面我们来说在SpringBoot2.x版本中如何使用cache。
1. 引入依赖
dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-cache/artifactId
/dependency
dependencygroupIdcom.github.ben-manes.caffeine/groupIdartifactIdcaffeine/artifactIdversion2.6.2/version
/dependency2. 添加注解开启缓存支持
添加EnableCaching注解
SpringBootApplication
EnableCaching
public class SingleDatabaseApplication {public static void main(String[] args) {SpringApplication.run(SingleDatabaseApplication.class, args);}
}3. 配置文件的方式注入相关参数
properties文件
spring.cache.cache-namescache1
spring.cache.caffeine.specinitialCapacity50,maximumSize500,expireAfterWrite10s
或Yaml文件
spring:cache:type: caffeinecache-names:- userCachecaffeine:spec: maximumSize1024,refreshAfterWrite60s如果使用refreshAfterWrite配置,必须指定一个CacheLoader.不用该配置则无需这个bean,如上所述,该CacheLoader将关联被该缓存管理器管理的所有缓存所以必须定义为CacheLoaderObject, Object自动配置将忽略所有泛型类型。
import com.github.benmanes.caffeine.cache.CacheLoader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** author: rickiyang* date: 2019/6/15* description:*/
Configuration
public class CacheConfig {/*** 相当于在构建LoadingCache对象的时候 build()方法中指定过期之后的加载策略方法* 必须要指定这个BeanrefreshAfterWrite60s属性才生效* return*/Beanpublic CacheLoaderString, Object cacheLoader() {CacheLoaderString, Object cacheLoader new CacheLoaderString, Object() {Overridepublic Object load(String key) throws Exception {return null;}// 重写这个方法将oldValue值返回回去进而刷新缓存Overridepublic Object reload(String key, Object oldValue) throws Exception {return oldValue;}};return cacheLoader;}
}Caffeine常用配置说明
initialCapacity[integer]: 初始的缓存空间大小maximumSize[long]: 缓存的最大条数maximumWeight[long]: 缓存的最大权重expireAfterAccess[duration]: 最后一次写入或访问后经过固定时间过期expireAfterWrite[duration]: 最后一次写入后经过固定时间过期refreshAfterWrite[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔刷新缓存weakKeys: 打开key的弱引用weakValues打开value的弱引用softValues打开value的软引用recordStats开发统计功能注意expireAfterWrite和expireAfterAccess同时存在时以expireAfterWrite为准。maximumSize和maximumWeight不可以同时使用weakValues和softValues不可以同时使用需要说明的是使用配置文件的方式来进行缓存项配置一般情况能满足使用需求但是灵活性不是很高如果我们有很多缓存项的情况下写起来会导致配置文件很长。所以一般情况下你也可以选择使用bean的方式来初始化Cache实例。
下面的演示使用bean的方式来注入
package com.rickiyang.learn.cache;import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.apache.commons.compress.utils.Lists;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;/*** author: rickiyang* date: 2019/6/15* description:*/
Configuration
public class CacheConfig {/*** 创建基于Caffeine的Cache Manager* 初始化一些key存入* return*/BeanPrimarypublic CacheManager caffeineCacheManager() {SimpleCacheManager cacheManager new SimpleCacheManager();ArrayListCaffeineCache caches Lists.newArrayList();ListCacheBean list setCacheBean();for(CacheBean cacheBean : list){caches.add(new CaffeineCache(cacheBean.getKey(),Caffeine.newBuilder().recordStats().expireAfterWrite(cacheBean.getTtl(), TimeUnit.SECONDS).maximumSize(cacheBean.getMaximumSize()).build()));}cacheManager.setCaches(caches);return cacheManager;}/*** 初始化一些缓存的 key* return*/private ListCacheBean setCacheBean(){ListCacheBean list Lists.newArrayList();CacheBean userCache new CacheBean();userCache.setKey(userCache);userCache.setTtl(60);userCache.setMaximumSize(10000);CacheBean deptCache new CacheBean();deptCache.setKey(userCache);deptCache.setTtl(60);deptCache.setMaximumSize(10000);list.add(userCache);list.add(deptCache);return list;}class CacheBean {private String key;private long ttl;private long maximumSize;public String getKey() {return key;}public void setKey(String key) {this.key key;}public long getTtl() {return ttl;}public void setTtl(long ttl) {this.ttl ttl;}public long getMaximumSize() {return maximumSize;}public void setMaximumSize(long maximumSize) {this.maximumSize maximumSize;}}}
创建了一个SimpleCacheManager作为Cache的管理对象然后初始化了两个Cache对象分别存储userdept类型的缓存。当然构建Cache的参数设置我写的比较简单你在使用的时候酌情根据需要配置参数。
4. 使用注解来对 cache 增删改查
我们可以使用spring提供的 Cacheable、CachePut、CacheEvict等注解来方便的使用caffeine缓存。
如果使用了多个cahce比如redis、caffeine等必须指定某一个CacheManage为primary在Cacheable注解中没指定 cacheManager 则使用标记为primary的那个。
cache方面的注解主要有以下5个 Cacheable 触发缓存入口这里一般放在创建和获取的方法上Cacheable注解会先查询是否已经有缓存有会使用缓存没有则会执行方法并缓存 CacheEvict 触发缓存的eviction用于删除的方法上 CachePut 更新缓存且不影响方法执行用于修改的方法上该注解下的方法始终会被执行 Caching 将多个缓存组合在一个方法上该注解可以允许一个方法同时设置多个注解 CacheConfig 在类级别设置一些缓存相关的共同配置与其它缓存配合使用
说一下Cacheable 和 CachePut的区别
Cacheable它的注解的方法是否被执行取决于Cacheable中的条件方法很多时候都可能不被执行。
CachePut这个注解不会影响方法的执行也就是说无论它配置的条件是什么方法都会被执行更多的时候是被用到修改上。
简要说一下Cacheable类中各个方法的使用
public interface Cacheable {/*** 要使用的cache的名字*/AliasFor(cacheNames)String[] value() default {};/*** 同value()决定要使用那个/些缓存*/AliasFor(value)String[] cacheNames() default {};/*** 使用SpEL表达式来设定缓存的key如果不设置默认方法上所有参数都会作为key的一部分*/String key() default ;/*** 用来生成key与key()不可以共用*/String keyGenerator() default ;/*** 设定要使用的cacheManager必须先设置好cacheManager的bean这是使用该bean的名字*/String cacheManager() default ;/*** 使用cacheResolver来设定使用的缓存用法同cacheManager但是与cacheManager不可以同时使用*/String cacheResolver() default ;/*** 使用SpEL表达式设定出发缓存的条件在方法执行前生效*/String condition() default ;/*** 使用SpEL设置出发缓存的条件这里是方法执行完生效所以条件中可以有方法执行后的value*/String unless() default ;/*** 用于同步的在缓存失效过期不存在等各种原因的时候如果多个线程同时访问被标注的方法* 则只允许一个线程通过去执行方法*/boolean sync() default false;}
基于注解的使用方法
package com.rickiyang.learn.cache;import com.rickiyang.learn.entity.User;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;/*** author: rickiyang* date: 2019/6/15* description: 本地cache*/
Service
public class UserCacheService {/*** 查找* 先查缓存如果查不到会查数据库并存入缓存* param id*/Cacheable(value userCache, key #id, sync true)public void getUser(long id){//查找数据库}/*** 更新/保存* param user*/CachePut(value userCache, key #user.id)public void saveUser(User user){//todo 保存数据库}/*** 删除* param user*/CacheEvict(value userCache,key #user.id)public void delUser(User user){//todo 保存数据库}
}如果你不想使用注解的方式去操作缓存也可以直接使用SimpleCacheManager获取缓存的key进而进行操作。
注意到上面的key使用了spEL 表达式。Spring Cache提供了一些供我们使用的SpEL上下文数据下表直接摘自Spring官方文档
名称位置描述示例methodNameroot对象当前被调用的方法名#root.methodnamemethodroot对象当前被调用的方法#root.method.nametargetroot对象当前被调用的目标对象实例#root.targettargetClassroot对象当前被调用的目标对象的类#root.targetClassargsroot对象当前被调用的方法的参数列表#root.args[0]cachesroot对象当前方法调用使用的缓存列表#root.caches[0].nameArgument Name执行上下文当前被调用的方法的参数如findArtisan(Artisan artisan),可以通过#artsian.id获得参数#artsian.idresult执行上下文方法执行后的返回值仅当方法执行后的判断有效如 unless cacheEvict的beforeInvocationfalse#result
注意
1.当我们要使用root对象的属性作为key时我们也可以将“#root”省略因为Spring默认使用的就是root对象的属性。如
Cacheable(key targetClass methodName #p0)2.使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”。如
Cacheable(valueuserCache, key#id)
Cacheable(valueuserCache, key#p0)SpEL提供了多种运算符
类型运算符关系!ltgtlegeeqne算术- * /%^逻辑||!andornotbetweeninstanceof条件?: (ternary)?: (elvis)正则表达式matches其他类型?.?[…]![…]^[…]$[…]
