总结：

一.使用二级缓存的好处是减少缓存数据的网络传输开销。当集中缓存出现故障时，Ehcache等本地缓存依然能支撑程序正常使用，这样增加了程序的健壮性。另外使用二级缓存策略可以在一定程度上阻止缓存穿透问题。

二.根据CAP原理可知，如果要使用强一致性缓存，集中式缓存是最佳选择。

 

2.Guava Cache缓存框架

(1)Guava Cache具有如下功能

(2)Guava Cache的主要设计思想

(3)Cuava Cache的优势

(4)Cuava Cache核心原理

(6)Guava Cache的单独使用和与Spring集成使用

(7)Guava Cache的几个问题

 

(1)Guava Cache具有如下功能

一.自动将Entry节点加载进缓存中

二.当缓存的数据超过设置的最大值时，使用LRU算法进行缓存清理

三.能够根据Entry节点上次被访问或者写入时间计算它的过期机制

四.缓存的key被封装在WeakReference引用内

五.缓存的value被封装在WeakReference或SoftReference引用内

六.能够统计在使用缓存的过程中命中率、异常率、未命中率等数据

 

(2)Guava Cache的主要设计思想

Guava Cache基于ConcurrentHashMap的设计思想，其内部大量使用了Segments细粒度锁，既保证线程安全，又提升了并发。

 

Guava Cache使用Reference引用，保证了GC可回收，有效节省了空间。

 

Guava Cache分别针对write操作和access操作去设计队列，这样的队列设计能更加灵活高效地实现多种数据类型的缓存清理策略。这些清理策略可以基于容量、可以基于时间、可以基于引用等来实现。

 

(3)Cuava Cache的优势

一.拥有缓存过期和淘汰机制

采用LRU将不常使用的键值从Cache中删除，淘汰策略还可以基于容量、时间、引用来实现。

 

二.拥有并发处理能力

GuavaCache类似CurrentHashMap，是线程安全的。它提供了设置并发级别的API，使得缓存支持并发的写入和读取。分段锁是分段锁定，把一个集合看分成若干Partition，每个Partiton一把锁。ConcurrentHashMap就是分了16个区域，这16个区域之间是可以并发的。GuavaCache采用Segment做分区。

 

三.缓存统计

可以统计缓存的加载、命中情况。

 

四.更新锁定

一般情况下，在缓存中查询某个key，如果不存在则查源数据，并回填缓存。高并发下可能会出现多次查源并回填缓存，造成数据源宕机，性能下降。GuavaCache可以在CacheLoader的load()方法中加以控制：对同一个key，只让一个请求去读源并回填缓存，其他请求阻塞等待。

 

(4)Cuava Cache核心原理

Guava Cache的数据结构和CurrentHashMap相似，核心区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。而Guava Cache为了限制内存占用，通常都设定为自动回收元素。

 

一.LocalCache为Guava Cache的核心类，有一个Segment数组

与ConcurrentHashMap类似，Guava Cache的并发也是通过分段锁来实现的。LoadingCache将映射表分为多个Segment，Segment元素之间可以并发访问。这样就能大大提高并发的效率，降低并发冲突的可能性。

 

二.Segement数组的长度决定了Cache的并发数

GuavaCache通过设置concurrencyLevel使得缓存支持并发的写入和读取，Segment数组的长度 = concurrencyLevel。

 

三.每一个Segment使用了单独的锁

每个Segment都继承ReentrantLock，对Segment的写操作需要先拿到锁，每个Segment由一个table和5个队列组成。

 

四.Segment的5个队列

队列一：键引用队列

已经被GC，需要内部清理的键引用队列。

ReferenceQueue<K> keyReferenceQueue，键引用队列

队列二：值引用队列

已经被GC，需要内部清理的值引用队列。

ReferenceQueue<V> valueReferenceQueue，值引用队列

队列三：LRU队列

当segment达到临界值发生写操作时该队列会移除数据。

Queue<ReferenceEntry<K, V>> recencyQueue，LRU队列

队列四：写队列

按写入时间进行排序的元素队列，写入一个元素时会把它加入到队列尾部。

Queue<ReferenceEntry<K, V>> writeQueue，写队列

队列五：访问队列

按访问时间进行排序的元素队列，访问一个元素时会把它加入到队列尾部。

Queue<ReferenceEntry<K, V>> accessQueue，访问队列

五.Segment的一个table

AtomicReferenceArray<ReferenceEntry<K, V>> table;

AtomicReferenceArray可以用原子方式更新其元素的对象引用数组，ReferenceEntry是Guava Cache中对一个键值对节点的抽象。每个ReferenceEntry数组项都是一 条ReferenceEntry链，且一个ReferenceEntry包含key、hash、valueReference、next字段(单链)。Guava Cache使用ReferenceEntry接口来封装一个键值对，使用ValueReference来封装Value值。

 

六.GuavaCache的回收机制

回收机制一：基于容量回收

在缓存项的数目达到限定值前，采用LRU回收方式。

 

回收机制二：定时回收

expireAfterAccess：缓存项在给定时间内没有被读写访问，则回收。回收顺序和基于大小回收一样(LRU)。

 

回收机制三：基于引用回收

通过使用弱引用的键、或弱引用的值、或软引用的值，在GC时回收。GuavaCache构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制，GuavaCache是在每次进行缓存操作时进行惰性删除：如get()或者put()的时候，判断缓存是否过期。

 

(6)Guava Cache的单独使用和与Spring集成使用

Guava Cache提供CacheBuilder生成器来创建缓存，可方便设置各种参数。

 

一.单独使用Guava Cache

通过LoadingCache + CacheLoader使用builder()方法创建缓存。

<!-- 引入Guava --> <dependency>     <groupId>com.google.guava</groupId>     <artifactId>guava</artifactId>     <version>19.0</version> </dependency>  public class LoadingCacheTest {     @Test     public void test1() throws InterruptedException {         LoadingCache<Long, User> loadingCache = CacheBuilder.newBuilder()             //指定并发级别             .concurrencyLevel(8)             //初始化大小，配合concurrentLevel做分段锁             .initialCapacity(60)             //缓存中最多可放多少个元素             .maximumSize(10)             //从写入开始计算，10s过期             .expireAfterWrite(10, TimeUnit.SECONDS)             //统计命中率             .recordStats()             //缓存中的元素被驱逐出去后会自动回调到这里             .removalListener(new RemovalListener<Long, User>() {                 @Override                 public void onRemoval(RemovalNotification<Long, User> notification) {                     Long key = notification.getKey();                     RemovalCause cause = notification.getCause();                     System.out.println("key: " + key + "被移除缓存，原因是: " + cause);                 }             })             //缓存中获取不到值，会回调到这里             .build(new CacheLoader<Long, User>() {                 @Override                 public User load(Long key) throws Exception {                     //可以在这里进行数据的加载                     System.out.println("去存储中加载数据" + key);                     return new User(key.toString(), "abc");                 }             });                      //10秒后缓存前面的缓存会陆续被移除         for (long i = 0; i < 20; i++) {             User user = loadingCache.getUnchecked(i);             System.out.println(user);             TimeUnit.SECONDS.sleep(1);         }          //统计缓存信息         System.out.println(loadingCache.stats().toString());     } }

二.Spring整合Guava Cache

由于Spring5并没有提供Guava的CacheManager，所以需要自定义CacheManager才能实现创建缓存，可以参考EhCacheCacheManager。

 

步骤一：编写com.guava.cache.GuavaCacheCacheManager

package com.guava.cache;  import com.google.common.cache.CacheBuilder; import org.springframework.cache.Cache; import org.springframework.cache.support.AbstractCacheManager; import java.util.Collection; import java.util.LinkedHashSet;  //因为Spring没有自带的Guava Cache的实现，所以这里参考EhCacheCacheManager的实现来进行自定义 public class GuavaCacheCacheManager extends AbstractCacheManager {     //用来加载当前CacheManager要管理哪些Cache     @Override     protected Collection<Cache> loadCaches() {         //获取所有的缓存Cache         com.google.common.cache.Cache<Object, Object> userCache = CacheBuilder.newBuilder().maximumSize(100).build();         GuavaCache guavaUserCache = new GuavaCache("userCache", userCache);         Collection<Cache> caches = new LinkedHashSet<Cache>();         caches.add(guavaUserCache);         return caches;     } }

步骤二：编写com.guava.cache.GuavaCache

注意：实现多级缓存时，一种实现是分别使用SpringCacheManager来管理本地缓存、使用Redisson来管理Redis分布式缓存，此时需要同时维护两份数据。另一种优雅的实现是自定义一个缓存。

 

在这个自定义的缓存里去持有本地缓存和分布式缓存，然后在该缓存的get()、put()等方法里完成本地缓存和分布式缓存的同步逻辑。比如在evict()方法里，通过MQ等中间件完成本地缓存和分布式缓存的同步逻辑。

package com.guava.cache;  import org.springframework.cache.Cache; import org.springframework.cache.support.SimpleValueWrapper;  //自定义Cache的场景： //1.集成Guava Cache时，仿照EhCacheCache来自定义一个GuavaCache //2.实现多级缓存时： //一种实现是使用SpringCacheManager来管理本地缓存，使用Redisson来管理Redis分布式缓存，此时需要同时维护两份数据； //另一种优雅的实现，就是自定义一个缓存，在这个缓存里去持有本地缓存和分布式缓存，然后在该缓存的get、put、evict方法里完成本地缓存和分布式缓存的同步逻辑 //比如在这里的evict()方法里，就需要通过MQ等方式完成本地缓存和分布式缓存的同步逻辑； public class GuavaCache implements Cache {     private String cacheName;//Cache的名字     //使用组合模式持有真正的Cache对象     private com.google.common.cache.Cache<Object, Object> internalCache;     public GuavaCache(String cacheName, com.google.common.cache.Cache<Object, Object> internalCache) {         this.cacheName = cacheName;         this.internalCache = internalCache;     }     public String getName() {         return cacheName;     }     public Object getNativeCache() {         return internalCache;     }     public ValueWrapper get(Object key) {         Object object = internalCache.getIfPresent(key);         if (object != null) {             //返回SimpleValueWrapper的默认实现             return new SimpleValueWrapper(object);         }         return null;     }     public <T> T get(Object key, Class<T> type) {         throw new RuntimeException("参考get实现");     }     public void put(Object key, Object value) {         internalCache.put(key, value);     }     public ValueWrapper putIfAbsent(Object key, Object value) {         internalCache.put(key, value);         Object object = internalCache.getIfPresent(key);         if (object != null) {             //返回SimpleValueWrapper的默认实现             return new SimpleValueWrapper(object);         }         return null;     }     //逐出     public void evict(Object key) {         internalCache.invalidate(key);     }     public void clear() {      } }

步骤三：配置spring/applicationContext-guava-cache.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns:cache="http://www.springframework.org/schema/cache"        xsi:schemaLocation="http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/cache         http://www.springframework.org/schema/cache/spring-cache-4.0.xsd">      <description>Guava Cache缓存配置管理文件</description>     <!-- 对原生的CacheManager进行包装，org.springframework.cache.CacheManager有多个实现 -->     <bean id="guavaCacheCacheManager" class="com.guava.cache.GuavaCacheCacheManager" />     <!-- 跟org.springframework.cache.annotation.EnableCaching一样 -->     <cache:annotation-driven proxy-target-class="true" cache-manager="guavaCacheCacheManager" />     <bean class="com.guava.cache.impl.UserServiceImpl" /> </beans>

步骤四：最后进行测试

import com.guava.cache.entity.User; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.cache.CacheManager; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import javax.annotation.Resource;  //注意： //Spring集成任何第三方框架的方式：通过xml注入或在@Configuration配置类中的@bean来注入 //SpringBoot集成任何第三方框架的方式：通过starter或@Configuration配置类中的@bean来注入 @ContextConfiguration(locations = {"classpath:spring/applicationContext-guava-cache.xml"}) @RunWith(SpringJUnit4ClassRunner.class) public class TestSpringGuavaCache {     @Resource     private CacheManager cacheManager;        @Resource     UserService userService;        //测试自定义CacheManager     //步骤一：编写com.guava.cache.GuavaCacheCacheManager     //步骤二：com.guava.cache.GuavaCache     //步骤三：配置spring/applicationContext-guava-cache.xml     @Test     public void test1() {         System.out.println(cacheManager.getClass());         User user = userService.getById(1L);         System.out.println("接口返回的结果: " + user);         String cache = String.valueOf(cacheManager.getCache("userCache").get(1L).get());         System.out.println("缓存读取的结果: " + cache);     } }

用于测试的接口：

package com.guava.cache.impl;  import com.guava.cache.UserService; import com.guava.cache.entity.User; import org.springframework.cache.annotation.CacheConfig; import org.springframework.cache.annotation.Cacheable;  @CacheConfig(cacheNames = {"userCache"}) public class UserServiceImpl implements UserService {     @Cacheable(key = "#id")     public User getById(Long id) {         System.out.println("模拟查询DB");         User user = new User();         user.setId(id);         user.setName("demo");         return user;     } }

(7)Guava Cache的几个问题

一.Guava Cache会OOM吗

会，当设置缓存永不过期或者很长，缓存的对象不限个数或者很大时，不断向GuavaCache加入大字符串，最终就会OOM。解决方案：缓存时间设置相对小些，使用弱引用方式存储对象。

 

二.Guava Cache缓存到期就会立即清除吗

不会，Guava Cache在每次进行缓存操作时，会判断缓存是否过期。如果一个对象放入缓存后，不再有任何缓存操作，则该缓存不会主动过期。

 

三.Guava Cache如何找出最久未使用的数据

accessQueue是按照LRU的顺序存放缓存对象(ReferenceEntry)的，accessQueue会把访问过的对象放到队列的最后。accessQueue可以很方便更新和删除链表中的节点，因为每次访问时都可能需要更新该链表，放入到链表的尾部。这样每次从access中拿出的头节点就是最久未使用的数据，writeQueue会用来保存最久未更新的缓存队列，和accessQueue一样。

 

3.自定义缓存

(1)缓存应该具备的功能

(2)基于LinkedHashMap来实现LRU淘汰策略

(3)基于LinkedList来实现LRU淘汰策略

(4)基于SoftReference实现缓存的内存敏感能力

 

(1)缓存应该具备的功能

一.最大能放多少个，超出数量时的溢出淘汰机制：LRU、FIFO、LFU

二.过期需要清除

三.内存要敏感，不能因缓存原因导致OOM

四.需要保证并发下的线程安全

五.统计命中率

六.可以序列化扩展

 

(2)基于LinkedHashMap来实现LRU淘汰策略

一.LinkedHashMap构造参数的accessOrder能够让访问过的元素排前面

public class SelfCacheTest {     //LRU: Least Recently Used     //要实现基于LRU算法的溢出驱逐；     //1.按访问时间来排序，访问时间最早的排前面；     //2.移除排在最前面；     @Test     public void test1() {         //正常普通使用LinkedHashMap，访问其元素不会影响排序         LinkedHashMap<String, String> linkedHashMap1 = new LinkedHashMap<String, String>();         linkedHashMap1.put("a", "a_value");         linkedHashMap1.put("b", "b_value");         linkedHashMap1.put("c", "c_value");         System.out.println(linkedHashMap1);          String bValue1 = linkedHashMap1.get("b");         System.out.println("b的值: " + bValue1);         System.out.println(linkedHashMap1);         System.out.println("...................");          //创建LinkedHashMap时将accessOrder参数设置为true，则后续访问过的元素会排前面         LinkedHashMap<String, String> linkedHashMap2 = new LinkedHashMap<String, String>(16, 0.75f, true);         linkedHashMap2.put("a", "a_value");         linkedHashMap2.put("b", "b_value");         linkedHashMap2.put("c", "c_value");         System.out.println(linkedHashMap2);          String bValue2 = linkedHashMap2.get("b");         System.out.println("b的值: " + bValue2);         System.out.println(linkedHashMap2);     } }

二.自定义一个缓存类来基于LinkedHashMap来实现LRU驱逐算法

使用LinkedHashMap来存放缓存对象，并设置accessOrder为true。

//基本的缓存功能接口 public interface Cache {     void put(Object key, Object value);     void remove(Object key);     void clear();     Object get(Object key);     int size(); }  //基于LinkedHashMap实现LRU驱逐算法 public class CacheVersion1 implements Cache {     //缓存容量     private int capacity;      //通过组合关系持有一个内部的真正缓存对象     private InternalCache internalCache;      private static class InternalCache extends LinkedHashMap<Object, Object> {         private int capacity;         public InternalCache(int capacity) {             super(16, 0.75f, true);             this.capacity = capacity;         }         @Override         protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {             return size() > capacity;         }     }      public CacheVersion1(int capacity) {         this.capacity = capacity;         internalCache = new InternalCache(capacity);     }      public void put(Object key, Object value) {         internalCache.put(key, value);     }      public void remove(Object key) {         internalCache.remove(key);     }      public void clear() {         internalCache.clear();     }      public Object get(Object key) {         return internalCache.get(key);     }      public int size() {         return internalCache.size();     }      @Override     public String toString() {         return "CacheVersion1{" +                 "capacity=" + capacity +                 ", internalCache=" + internalCache +                 '}';     } }  public class SelfCacheTest {     @Test     public void testCacheVersion1() {         Cache cache = new CacheVersion1(3);         cache.put("a", "a_value");         cache.put("b", "b_value");         cache.put("c", "c_value");         System.out.println(cache);          //访问测试，看看是否改变排序         String bValue = (String)cache.get("b");         System.out.println("b的值: " + bValue);         System.out.println(cache);          //测试是否满了移除         cache.put("d", "d_value");         System.out.println(cache);     } }

(3)基于LinkedList来实现LRU淘汰策略

使用LinkedList用来存放缓存key的顺序，使用Map来存放缓存对象。

//基于LinkedList实现LRU驱逐算法 public class CacheVersion2 implements Cache {     //缓存容量     private int capacity;      //用来维护缓存key的顺序     private LinkedList<Object> keyList;      //通过组合关系持有一个内部的真正缓存对象     private Map<Object, Object> internalCache;      public CacheVersion2(int capacity) {         this.capacity = capacity;         keyList = new LinkedList<Object>();         internalCache = new HashMap<Object, Object>();     }      public void put(Object key, Object value) {         //调用此方法时，已存在的元素等于容量大小了         if (size() == capacity) {             //移除第一个，因为在get()方法中设置了最新访问的放在最后             Object firstKey = keyList.removeFirst();             internalCache.remove(firstKey);         }         keyList.addLast(key);         internalCache.put(key, value);     }      public void remove(Object key) {         keyList.remove(key);         internalCache.remove(key);     }      public void clear() {         keyList.clear();         internalCache.clear();     }      public Object get(Object key) {         //如果key存在在true，如果key不存在则false         boolean removeResult = keyList.remove(key);         if (removeResult) {             Object value = internalCache.get(key);             //把现在访问的key排序，最新访问的放在最后             keyList.addLast(key);             return value;         }         return null;     }      public int size() {         return internalCache.size();     }      @Override     public String toString() {         StringBuilder sb = new StringBuilder();         for (Object key : keyList) {             sb.append("key:").append(key).append(",").append("value:").append(internalCache.get(key)).append("-----");         }         return sb.toString();     } }

(4)基于SoftReference实现缓存的内存敏感能力

强引用：只要有引用就不会被回收，即便OOM

软引用：在GC且堆内存快OOM时才会被回收

弱引用：每次GC都会被回收

虚引用：随时都可能被回收

 

首先对put进去的value值进行SoftReference包装，然后put的是软引用包装后的vale，接着在get的时候先取出软引用包装的值，再返回具体值。

//基于LinkedHashMap实现LRU驱逐算法 + 内存敏感 public class CacheVersionFinal implements Cache {     //缓存容量     private int capacity;      //通过组合关系持有一个内部的真正缓存对象     private InternalCache internalCache;      private static class InternalCache extends LinkedHashMap<Object, Object> {         private int capacity;         public InternalCache(int capacity) {             super(16, 0.75f, true);             this.capacity = capacity;         }         @Override         protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {             return size() > capacity;         }     }      public CacheVersionFinal(int capacity) {         this.capacity = capacity;         internalCache = new InternalCache(capacity);     }      public void put(Object key, Object value) {         SoftReference<Object> softReference = new SoftReference<Object>(value);         internalCache.put(key, softReference);     }      public void remove(Object key) {         internalCache.remove(key);     }      public void clear() {         internalCache.clear();     }      public Object get(Object key) {         Object o = internalCache.get(key);         if (o == null) {             return null;         }         SoftReference<Object> softReference = (SoftReference<Object>) o;         //返回引用的真实对象         return softReference.get();     }      public int size() {         return internalCache.size();     }      @Override     public String toString() {         return "CacheVersion1{" +                 "capacity=" + capacity +                 ", internalCache=" + internalCache +                 '}';     } }  public class Dept {     private Long id;     private byte[] bytes = new byte[1024 * 1024];          public Dept(Long id) {         this.id = id;     }          public Long getId() {         return id;     }       public void setId(Long id) {         this.id = id;     }          public byte[] getBytes() {         return bytes;     }      public void setBytes(byte[] bytes) {         this.bytes = bytes;     }      //JVM要回收这个对象时，会回调这个方法     //可以在该方法里完成资源的清理，或者完成自救     @Override     protected void finalize() throws Throwable {         System.out.println(id + "将要被回收，需要自救.............");     } }  public class SelfCacheTest {     //测试软引用的内存敏感     //-Xms10M -Xmx10M -XX:+PrintGCDetails     @Test     public void test3() throws InterruptedException {         Cache cache = new CacheVersionFinal(5000);         for (int i = 1; i < Integer.MAX_VALUE; i++) {             System.out.println("放入第" + i + "个");             Dept dept = new Dept((long) i);             cache.put(dept.getId(), dept);             TimeUnit.SECONDS.sleep(1);         }     } }