Guava Cache

Posted xuwc

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Guava Cache相关的知识，希望对你有一定的参考价值。

背景

缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日长开发有很多场合，有一些数据量不是很大，不会经常改动，并且访问非常频繁。但是由于受限于硬盘IO的性能或者远程网络等原因获取可能非常的费时。会导致我们的程序非常缓慢，这在某些业务上是不能忍的！而缓存正是解决这类问题的神器！

 
技术图片

当然也并不是说你用了缓存你的系统就一定会变快，建议在用之前看一下使用缓存的9大误区(上) 使用缓存的9大误区(下)

缓存在很多系统和架构中都用广泛的应用,例如：

  • CPU缓存
  • 操作系统缓存
  • HTTP缓存
  • 数据库缓存
  • 静态文件缓存
  • 本地缓存
  • 分布式缓存

可以说在计算机和网络领域，缓存是无处不在的。可以这么说，只要有硬件性能不对等，涉及到网络传输的地方都会有缓存的身影。

缓存总体可分为两种 集中式缓存 和 分布式缓存

“集中式缓存"与"分布式缓存"的区别其实就在于“集中”与"非集中"的概念，其对象可能是服务器、内存条、硬盘等。比如：

1.服务器版本：
  • 缓存集中在一台服务器上，为集中式缓存。
  • 缓存分散在不同的服务器上，为分布式缓存。
2.内存条版本：
  • 缓存集中在一台服务器的一条内存条上，为集中式缓存。
  • 缓存分散在一台服务器的不同内存条上，为分布式缓存。
3.硬盘版本：
  • 缓存集中在一台服务器的一个硬盘上，为集中式缓存。
  • 缓存分散在一台服务器的不同硬盘上，为分布式缓存。

想了解分布式缓存可以看一下浅谈分布式缓存那些事儿。

这是几个当前比较流行的java 分布式缓存框架5个强大的Java分布式缓存框架推荐。

而我们今天要讲的是集中式内存缓存guava cache,这是当前我们项目正在用的缓存工具，研究一下感觉还蛮好用的。当然也有很多其他工具，还是看个人喜欢。oschina上面也有很多类似开源的java缓存框架

正文

Guava Cache与ConcurrentMap很相似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。在某些场景下，尽管LoadingCache 不回收元素，它也是很有用的，因为它会自动加载缓存。

Guava Cache是在内存中缓存数据，相比较于数据库或redis存储，访问内存中的数据会更加高效。Guava官网介绍，下面的这几种情况可以考虑使用Guava Cache：

  1. 愿意消耗一些内存空间来提升速度。

  2. 预料到某些键会被多次查询。

  3. 缓存中存放的数据总量不会超出内存容量。

所以，可以将程序频繁用到的少量数据存储到Guava Cache中，以改善程序性能。下面对Guava Cache的用法进行详细的介绍。

构建缓存对象

接口Cache代表一块缓存，它有如下方法：

技术图片
 1 public interface Cache<K, V> {
 2     V get(K key, Callable<? extends V> valueLoader) throws ExecutionException;
 3 
 4     ImmutableMap<K, V> getAllPresent(Iterable<?> keys);
 5 
 6     void put(K key, V value);
 7 
 8     void putAll(Map<? extends K, ? extends V> m);
 9 
10     void invalidate(Object key);
11 
12     void invalidateAll(Iterable<?> keys);
13 
14     void invalidateAll();
15 
16     long size();
17 
18     CacheStats stats();
19 
20     ConcurrentMap<K, V> asMap();
21 
22     void cleanUp();
23 }
技术图片

可以通过CacheBuilder类构建一个缓存对象，CacheBuilder类采用builder设计模式，它的每个方法都返回CacheBuilder本身，直到build方法被调用。构建一个缓存对象代码如下。

技术图片
1 public class StudyGuavaCache {
2     public static void main(String[] args) {
3         Cache<String,String> cache = CacheBuilder.newBuilder().build();
4         cache.put("word","Hello Guava Cache");
5         System.out.println(cache.getIfPresent("word"));
6     }
7 }
技术图片

上面的代码通过CacheBuilder.newBuilder().build()这句代码创建了一个Cache缓存对象，并在缓存对象中存储了key为word，value为Hello Guava Cache的一条记录。可以看到Cache非常类似于JDK中的Map，但是相比于Map，Guava Cache提供了很多更强大的功能。

从LoadingCache查询的正规方式是使用get(K)方法。这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值（通过load(String key) 方法加载）。由于CacheLoader可能抛出异常，LoadingCache.get(K)也声明抛出ExecutionException异常。如果你定义的CacheLoader没有声明任何检查型异常，则可以通过getUnchecked(K)查找缓存；但必须注意，一旦CacheLoader声明了检查型异常，就不可以调用getUnchecked(K)。
技术图片
 1 LoadingCache<Key, Value> cache = CacheBuilder.newBuilder()
 2        .build(
 3            new CacheLoader<Key, Value>() {
 4              public Value load(Key key) throws AnyException {
 5                return createValue(key);
 6              }
 7            });
 8 ...
 9 try {
10   return cache.get(key);
11 } catch (ExecutionException e) {
12   throw new OtherException(e.getCause());
13 }
技术图片

设置最大存储

Guava Cache可以在构建缓存对象时指定缓存所能够存储的最大记录数量。当Cache中的记录数量达到最大值后再调用put方法向其中添加对象，Guava会先从当前缓存的对象记录中选择一条删除掉，腾出空间后再将新的对象存储到Cache中。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .build();
 6         cache.put("key1","value1");
 7         cache.put("key2","value2");
 8         cache.put("key3","value3");
 9         System.out.println("第一个值：" + cache.getIfPresent("key1"));
10         System.out.println("第二个值：" + cache.getIfPresent("key2"));
11         System.out.println("第三个值：" + cache.getIfPresent("key3"));
12     }
13 }
技术图片

上面代码在构造缓存对象时，通过CacheBuilder类的maximumSize方法指定Cache最多可以存储两个对象，然后调用Cache的put方法向其中添加了三个对象。程序执行结果如下图所示，可以看到第三条对象记录的插入，导致了第一条对象记录被删除。
技术图片

设置过期时间

在构建Cache对象时，可以通过CacheBuilder类的expireAfterAccess和expireAfterWrite两个方法为缓存中的对象指定过期时间，使用`CacheBuilder`构建的缓存不会“自动”执行清理和逐出值，也不会在值到期后立即执行或逐出任何类型。相反，它在写入操作期间执行少量维护，或者在写入很少的情况下偶尔执行读取操作。其中，expireAfterWrite方法指定对象被写入到缓存后多久过期，expireAfterAccess指定对象多久没有被访问后过期。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .expireAfterWrite(3,TimeUnit.SECONDS)
 6                 .build();
 7         cache.put("key1","value1");
 8         int time = 1;
 9         while(true) {
10             System.out.println("第" + time++ + "次取到key1的值为：" + cache.getIfPresent("key1"));
11             Thread.sleep(1000);
12         }
13     }
14 }
技术图片

上面的代码在构造Cache对象时，通过CacheBuilder的expireAfterWrite方法指定put到Cache中的对象在3秒后会过期。在Cache对象中存储一条对象记录后，每隔1秒读取一次这条记录。程序运行结果如下图所示，可以看到，前三秒可以从Cache中获取到对象，超过三秒后，对象从Cache中被自动删除。
技术图片

下面代码是expireAfterAccess的例子。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .expireAfterAccess(3,TimeUnit.SECONDS)
 6                 .build();
 7         cache.put("key1","value1");
 8         int time = 1;
 9         while(true) {
10             Thread.sleep(time*1000);
11             System.out.println("睡眠" + time++ + "秒后取到key1的值为：" + cache.getIfPresent("key1"));
12         }
13     }
14 }
技术图片

通过CacheBuilder的expireAfterAccess方法指定Cache中存储的对象如果超过3秒没有被访问就会过期。while中的代码每sleep一段时间就会访问一次Cache中存储的对象key1，每次访问key1之后下次sleep的时间会加长一秒。程序运行结果如下图所示，从结果中可以看出，当超过3秒没有读取key1对象之后，该对象会自动被Cache删除。
技术图片

也可以同时用expireAfterAccess和expireAfterWrite方法指定过期时间，这时只要对象满足两者中的一个条件就会被自动过期删除。

Guava Cache缓存过期后不一定会立马被清理，一般会在Cache整体被读取一定次数后清理。这中策略对性能是有好处的，如果想强制清理可以手动调用`Cache.cleanup()`或者使用`ScheduledExecutorService`来完成定期清理

弱引用

可以通过weakKeys和weakValues方法指定Cache只保存对缓存记录key和value的弱引用。这样当没有其他强引用指向key和value时，key和value对象就会被垃圾回收器回收。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,Object> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .weakValues()
 6                 .build();
 7         Object value = new Object();
 8         cache.put("key1",value);
 9 
10         value = new Object();//原对象不再有强引用
11         System.gc();
12         System.out.println(cache.getIfPresent("key1"));
13     }
14 }
技术图片

上面代码的打印结果是null。构建Cache时通过weakValues方法指定Cache只保存记录值的一个弱引用。当给value引用赋值一个新的对象之后，就不再有任何一个强引用指向原对象。System.gc()触发垃圾回收后，原对象就被清除了。

显示清除

可以调用Cache的invalidateAll或invalidate方法显示删除Cache中的记录。invalidate方法一次只能删除Cache中一个记录，接收的参数是要删除记录的key。invalidateAll方法可以批量删除Cache中的记录，当没有传任何参数时，invalidateAll方法将清除Cache中的全部记录。invalidateAll也可以接收一个Iterable类型的参数，参数中包含要删除记录的所有key值。下面代码对此做了示例。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder().build();
 4         Object value = new Object();
 5         cache.put("key1","value1");
 6         cache.put("key2","value2");
 7         cache.put("key3","value3");
 8 
 9         List<String> list = new ArrayList<String>();
10         list.add("key1");
11         list.add("key2");
12 
13         cache.invalidateAll(list);//批量清除list中全部key对应的记录
14         System.out.println(cache.getIfPresent("key1"));
15         System.out.println(cache.getIfPresent("key2"));
16         System.out.println(cache.getIfPresent("key3"));
17     }
18 }
技术图片

代码中构造了一个集合list用于保存要删除记录的key值，然后调用invalidateAll方法批量删除key1和key2对应的记录，只剩下key3对应的记录没有被删除。

移除监听器

可以为Cache对象添加一个移除监听器，这样当有记录被删除时可以感知到这个事件。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         RemovalListener<String, String> listener = new RemovalListener<String, String>() {
 4             public void onRemoval(RemovalNotification<String, String> notification) {
 5                 System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
 6             }
 7         };
 8         Cache<String,String> cache = CacheBuilder.newBuilder()
 9                 .maximumSize(3)
10                 .removalListener(listener)
11                 .build();
12         Object value = new Object();
13         cache.put("key1","value1");
14         cache.put("key2","value2");
15         cache.put("key3","value3");
16         cache.put("key4","value3");
17         cache.put("key5","value3");
18         cache.put("key6","value3");
19         cache.put("key7","value3");
20         cache.put("key8","value3");
21     }
22 }
技术图片

removalListener方法为Cache指定了一个移除监听器，这样当有记录从Cache中被删除时，监听器listener就会感知到这个事件。程序运行结果如下图所示。
技术图片

自动加载

Cache的get方法有两个参数，第一个参数是要从Cache中获取记录的key，第二个记录是一个Callable对象。当缓存中已经存在key对应的记录时，get方法直接返回key对应的记录。如果缓存中不包含key对应的记录，Guava会启动一个线程执行Callable对象中的call方法，call方法的返回值会作为key对应的值被存储到缓存中，并且被get方法返回。下面是一个多线程的例子：

技术图片
 1 public class StudyGuavaCache {
 2 
 3     private static Cache<String,String> cache = CacheBuilder.newBuilder()
 4             .maximumSize(3)
 5             .build();
 6 
 7     public static void main(String[] args) throws InterruptedException {
 8 
 9         new Thread(new Runnable() {
10             public void run() {
11                 System.out.println("thread1");
12                 try {
13                     String value = cache.get("key", new Callable<String>() {
14                         public String call() throws Exception {
15                             System.out.println("load1"); //加载数据线程执行标志
16                             Thread.sleep(1000); //模拟加载时间
17                             return "auto load by Callable";
18                         }
19                     });
20                     System.out.println("thread1 " + value);
21                 } catch (ExecutionException e) {
22                     e.printStackTrace();
23                 }
24             }
25         }).start();
26 
27         new Thread(new Runnable() {
28             public void run() {
29                 System.out.println("thread2");
30                 try {
31                     String value = cache.get("key", new Callable<String>() {
32                         public String call() throws Exception {
33                             System.out.println("load2"); //加载数据线程执行标志
34                             Thread.sleep(1000); //模拟加载时间
35                             return "auto load by Callable";
36                         }
37                     });
38                     System.out.println("thread2 " + value);
39                 } catch (ExecutionException e) {
40                     e.printStackTrace();
41                 }
42             }
43         }).start();
44     }
45 }
技术图片

这段代码中有两个线程共享同一个Cache对象，两个线程同时调用get方法获取同一个key对应的记录。由于key对应的记录不存在，所以两个线程都在get方法处阻塞。此处在call方法中调用Thread.sleep(1000)模拟程序从外存加载数据的时间消耗。代码的执行结果如下图：
技术图片

从结果中可以看出，虽然是两个线程同时调用get方法，但只有一个get方法中的Callable会被执行(没有打印出load2)。Guava可以保证当有多个线程同时访问Cache中的一个key时，如果key对应的记录不存在，Guava只会启动一个线程执行get方法中Callable参数对应的任务加载数据存到缓存。当加载完数据后，任何线程中的get方法都会获取到key对应的值。

统计信息

可以对Cache的命中率、加载数据时间等信息进行统计。在构建Cache对象时，可以通过CacheBuilder的recordStats方法开启统计信息的开关。开关开启后Cache会自动对缓存的各种操作进行统计，调用Cache的stats方法可以查看统计后的信息。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(3)
 5                 .recordStats() //开启统计信息开关
 6                 .build();
 7         cache.put("key1","value1");
 8         cache.put("key2","value2");
 9         cache.put("key3","value3");
10         cache.put("key4","value4");
11 
12         cache.getIfPresent("key1");
13         cache.getIfPresent("key2");
14         cache.getIfPresent("key3");
15         cache.getIfPresent("key4");
16         cache.getIfPresent("key5");
17         cache.getIfPresent("key6");
18 
19         System.out.println(cache.stats()); //获取统计信息
20     }
21 }
技术图片

程序执行结果如下图所示：
技术图片

这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中应该密切关注这些数据

LoadingCache

LoadingCache是Cache的子接口，相比较于Cache，当从LoadingCache中读取一个指定key的记录时，如果该记录不存在，则LoadingCache可以自动执行加载数据到缓存的操作。LoadingCache接口的定义如下：

技术图片
 1 public interface LoadingCache<K, V> extends Cache<K, V>, Function<K, V> {
 2 
 3     V get(K key) throws ExecutionException;
 4 
 5     V getUnchecked(K key);
 6 
 7     ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException;
 8 
 9     V apply(K key);
10 
11     void refresh(K key);
12 
13     @Override
14     ConcurrentMap<K, V> asMap();
15 }
技术图片

与构建Cache类型的对象类似，LoadingCache类型的对象也是通过CacheBuilder进行构建，不同的是，在调用CacheBuilder的build方法时，必须传递一个CacheLoader类型的参数，CacheLoader的load方法需要我们提供实现。当调用LoadingCache的get方法时，如果缓存不存在对应key的记录，则CacheLoader中的load方法会被自动调用从外存加载数据，load方法的返回值会作为key对应的value存储到LoadingCache中，并从get方法返回。

技术图片
 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws ExecutionException {
 3         CacheLoader<String, String> loader = new CacheLoader<String, String> () {
 4             public String load(String key) throws Exception {
 5                 Thread.sleep(1000); //休眠1s，模拟加载数据
 6                 System.out.println(key + " is loaded from a cacheLoader!");
 7                 return key + "‘s value";
 8             }
 9         };
10 
11         LoadingCache<String,String> loadingCache = CacheBuilder.newBuilder()
12                 .maximumSize(3)
13                 .build(loader);//在构建时指定自动加载器
14 
15         loadingCache.get("key1");
16         loadingCache.get("key2");
17         loadingCache.get("key3");
18     }
19 }
技术图片

程序执行结果如下图所示：
技术图片

转自：

https://segmentfault.com/a/1190000011105644

https://www.jianshu.com/p/64b0df87e51b

 

 
 

对于Guava Cache本身就不多做介绍了，一个非常好用的本地cache lib，可以完全取代自己手动维护ConcurrentHashMap。

背景

目前需要开发一个接口I，对性能要求有非常高的要求，TP99.9在20ms以内。初步开发后发现耗时完全无法满足，mysql稍微波动就超时了。

 

技术图片

 

主要耗时在DB读取，请求一次接口会读取几次配置表Entry表。而Entry表的信息更新又不频繁，对实时性要求不高，所以想到了对DB做一个cache，理论上就可以大幅度提升接口性能了。

 

DB表结构（这里的代码都是为了演示，不过原理、流程和实际生产环境基本是一致的）

技术图片
CREATE TABLE `entry` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` int(11) NOT NULL,
  `value` varchar(50) NOT NULL DEFAULT ‘‘,
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
技术图片

 

接口中的查询是根据name进行select操作，这次的目的就是设计一个cache类，将DB查询cache化。

 

基础使用

首先，自然而然的想到了最基本的guava cache的使用，如下：

技术图片
@Slf4j
@Component
public class EntryCache {

    @Autowired
    EntryMapper entryMapper;

    /**
     * guava cache 缓存实体
     */
    LoadingCache<String, Entry> cache = CacheBuilder.newBuilder()
            // 缓存刷新时间
            .refreshAfterWrite(10, TimeUnit.MINUTES)
            // 设置缓存个数
            .maximumSize(500)
            .build(new CacheLoader<String, Entry>() {
                @Override
                // 当本地缓存命没有中时，调用load方法获取结果并将结果缓存
                public Entry load(String appKey) {
                    return getEntryFromDB(appKey);
                }
                
                // 数据库进行查询
                private Entry getEntryFromDB(String name) {
                    log.info("load entry info from db!entry:{}", name);
                    return entryMapper.selectByName(name);
                }
            });

    /**
     * 对外暴露的方法
     * 从缓存中取entry，没取到就走数据库
     */
    public Entry getEntry(String name) throws ExecutionException {
        return cache.get(name);
    }
    
}
技术图片

这里用了refreshAfterWrite，和expireAfterWrite区别是expireAfterWrite到期会直接删除缓存，如果同时多个并发请求过来，这些请求都会重新去读取DB来刷新缓存。DB速度较慢，会造成线程短暂的阻塞（相对于读cache）。

而refreshAfterWrite，则不会删除cache，而是只有一个请求线程会去真实的读取DB，其他请求直接返回老值。这样可以避免同时过期时大量请求被阻塞，提升性能。

但是还有一个问题，那就是更新线程还是会被阻塞，这样在缓存key集体过期时，可能还会使响应时间变得不满足要求。

 

后台线程刷新

就像上面所说，只要刷新缓存，就必然有线程被阻塞，这个是无法避免的。

虽然无法避免线程阻塞，但是我们可以避免阻塞用户线程，让用户无感知即可。

所以，我们可以把刷新线程放到后台执行。当key过期时，有新用户线程读取cache时，开启一个新线程去load DB的数据，用户线程直接返回老的值，这样就解决了这个问题。

代码修改如下：

技术图片
@Slf4j
@Component
public class EntryCache {

    @Autowired
    EntryMapper entryMapper;

    ListeningExecutorService backgroundRefreshPools =
            MoreExecutors.listeningDecorator(new ThreadPoolExecutor(10, 10,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>()));

    /**
     * guava cache 缓存实体
     */
    LoadingCache<String, Entry> cache = CacheBuilder.newBuilder()
            // 缓存刷新时间
            .refreshAfterWrite(10, TimeUnit.MINUTES)
            // 设置缓存个数
            .maximumSize(500)
            .build(new CacheLoader<String, Entry>() {
                @Override
                // 当本地缓存命没有中时，调用load方法获取结果并将结果缓存
                public Entry load(String appKey) {
                    return getEntryFromDB(appKey);
                }

                @Override
                // 刷新时，开启一个新线程异步刷新，老请求直接返回旧值，防止耗时过长
                public ListenableFuture<Entry> reload(String key, Entry oldValue) throws Exception {
                    return backgroundRefreshPools.submit(() -> getEntryFromDB(key));
                }

                // 数据库进行查询
                private Entry getEntryFromDB(String name) {
                    log.info("load entry info from db!entry:{}", name);
                    return entryMapper.selectByName(name);
                }
            });

    /**
     * 对外暴露的方法
     * 从缓存中取entry，没取到就走数据库
     */
    public Entry getEntry(String name) throws ExecutionException {
        return cache.get(name);
    }

    /**
     * 销毁时关闭线程池
     */
    @PreDestroy
    public void destroy(){
        try {
            backgroundRefreshPools.shutdown();
        } catch (Exception e){
            log.error("thread pool showdown error!e:{}",e.getMessage());
        }

    }
}
技术图片

 

改动就是新添加了一个backgroundRefreshPools线程池，重写了一个reload方法。

ListeningExecutorService是guava的concurrent包里的类，负责一些线程池相关的工作，感兴趣的可以自己去了解一下。

在reload方法里提交一个新的线程，就可以用这个线程来刷新cache了。

如果刷新cache没有完成的时候有其他线程来请求该key，则会直接返回老值。

同时，千万不要忘记销毁线程池。

 

初始化问题

上面两步达到了不阻塞刷新cache的功能，但是这个前提是这些cache已经存在。

项目刚刚启动的时候，所有的cache都是不存在的，这个时候如果大批量请求过来，同样会被阻塞，因为没有老的值供返回，都得等待cache的第一次load完毕。

解决这个问题的方法就是在项目启动的过程中，将所有的cache预先load过来，这样用户请求刚到服务器时就会直接读cache，不用等待。

技术图片
@Slf4j
@Component
public class EntryCache {

    @Autowired
    EntryMapper entryMapper;

    ListeningExecutorService backgroundRefreshPools =
            MoreExecutors.listeningDecorator(new ThreadPoolExecutor(10, 10,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>()));

    /**
     * guava cache 缓存实体
     */
    LoadingCache<String, Entry> cache = CacheBuilder.newBuilder()
            // 缓存刷新时间
            .refreshAfterWrite(10, TimeUnit.MINUTES)
            // 设置缓存个数
            .maximumSize(500)
            .build(new CacheLoader<String, Entry>() {
                @Override
                // 当本地缓存命没有中时，调用load方法获取结果并将结果缓存
                public Entry load(String appKey) {
                    return getEntryFromDB(appKey);
                }

                @Override
                // 刷新时，开启一个新线程异步刷新，老请求直接返回旧值，防止耗时过长
                public ListenableFuture<Entry> reload(String key, Entry oldValue) throws Exception {
                    return backgroundRefreshPools.submit(() -> getEntryFromDB(key));
                }

                // 数据库进行查询
                private Entry getEntryFromDB(String name) {
                    log.info("load entry info from db!entry:{}", name);
                    return entryMapper.selectByName(name);
                }
            });

    /**
     * 对外暴露的方法
     * 从缓存中取entry，没取到就走数据库
     */
    public Entry getEntry(String name) throws ExecutionException {
        return cache.get(name);
    }

    /**
     * 销毁时关闭线程池
     */
    @PreDestroy
    public void destroy(){
        try {
            backgroundRefreshPools.shutdown();
        } catch (Exception e){
            log.error("thread pool showdown error!e:{}",e.getMessage());
        }

    }

    @PostConstruct
    public void initCache() {
        log.info("init entry cache start!");
        //读取所有记录
        List<Entry> list = entryMapper.selectAll();

        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        for (Entry entry : list) {
            try {
                this.getEntry(entry.getName());
            } catch (Exception e) {
                log.error("init cache error!,e:{}", e.getMessage());
            }
        }
        log.info("init entry cache end!");
    }
}
技术图片

结果

让我们用数据看看这个cache类的表现：

技术图片

200QPS，TP99.9是9ms，完美达标。

可以看出来，合理的使用缓存对接口性能还是有很大提升的。

 

 

Guava Cache(三)

Guava 源码分析之Cache的实现原理

前言

Google 出的 Guava 是 Java 核心增强的库，应用非常广泛。

我平时用的也挺频繁，这次就借助日常使用的 Cache 组件来看看 Google 大牛们是如何设计的。

缓存

本次主要讨论缓存。缓存在日常开发中举足轻重，如果你的应用对某类数据有着较高的读取频次，并且改动较小时那就非常适合利用缓存来提高性能。

缓存之所以可以提高性能是因为它的读取效率很高，就像是 CPU 的 L1、L2、L3 缓存一样，级别越高相应的读取速度也会越快。

但也不是什么好处都占，读取速度快了但是它的内存更小资源更宝贵，所以我们应当缓存真正需要的数据。其实也就是典型的空间换时间。下面谈谈 Java 中所用到的缓存。

 

JVM 缓存

首先是 JVM 缓存，也可以认为是堆缓存。

其实就是创建一些全局变量，如 Map、List 之类的容器用于存放数据。

这样的优势是使用简单但是也有以下问题：

  • 只能显式的写入，清除数据。
  • 不能按照一定的规则淘汰数据，如 LRU，LFU，FIFO 等。
  • 清除数据时的回调通知。
  • 其他一些定制功能等。

Ehcache、Guava Cache

所以出现了一些专门用作 JVM 缓存的开源工具出现了，如本文提到的 Guava Cache。

它具有上文 JVM 缓存不具有的功能，如自动清除数据、多种清除算法、清除回调等。

但也正因为有了这些功能，这样的缓存必然会多出许多东西需要额外维护，自然也就增加了系统的消耗。

分布式缓存

刚才提到的两种缓存其实都是堆内缓存，只能在单个节点中使用，这样在分布式场景下就招架不住了。

于是也有了一些缓存中间件，如 Redis、Memcached，在分布式环境下可以共享内存。

具体不在本次的讨论范围。

Guava Cache 示例

之所以想到 Guava 的 Cache，也是最近在做一个需求，大体如下：

从 Kafka 实时读取出应用系统的日志信息，该日志信息包含了应用的健康状况。
如果在时间窗口 N 内发生了 X 次异常信息，相应的我就需要作出反馈（报警、记录日志等）。

对此 Guava 的 Cache 就非常适合，我利用了它的 N 个时间内不写入数据时缓存就清空的特点，在每次读取数据时判断异常信息是否大于 X 即可。

伪代码如下：

    @Value("${alert.in.time:2}")
    private int time ;

    @Bean
    public LoadingCache buildCache(){
        return CacheBuilder.newBuilder()
                .expireAfterWrite(time, TimeUnit.MINUTES)
                .build(new CacheLoader<Long, AtomicLong>() {
                    @Override
                    public AtomicLong load(Long key) throws Exception {
                        return new AtomicLong(0);
                    }
                });
    }


    /**
     * 判断是否需要报警
     */
    public void checkAlert() {
        try {
            if (counter.get(KEY).incrementAndGet() >= limit) {
                LOGGER.info("***********报警***********");

                //将缓存清空
                counter.get(KEY).getAndSet(0L);
            }
        } catch (ExecutionException e) {
            LOGGER.error("Exception", e);
        }
    }

首先是构建了 LoadingCache 对象，在 N 分钟内不写入数据时就回收缓存（当通过 Key 获取不到缓存时，默认返回 0）。

然后在每次消费时候调用 checkAlert() 方法进行校验，这样就可以达到上文的需求。

我们来设想下 Guava 它是如何实现过期自动清除数据，并且是可以按照 LRU 这样的方式清除的。

大胆假设下：

内部通过一个队列来维护缓存的顺序，每次访问过的数据移动到队列头部，并且额外开启一个线程来判断数据是否过期，过期就删掉。有点类似于我之前写过的 动手实现一个 LRU cache

胡适说过：大胆假设小心论证

下面来看看 Guava 到底是怎么实现。

原理分析

看原理最好不过是跟代码一步步走了：

示例代码在这里：

https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/guava/CacheLoaderTest.java

技术图片8.png

为了能看出 Guava 是怎么删除过期数据的在获取缓存之前休眠了 5 秒钟，达到了超时条件。

技术图片2.png

最终会发现在 com.google.common.cache.LocalCache 类的 2187 行比较关键。

再跟进去之前第 2182 行会发现先要判断 count 是否大于 0，这个 count 保存的是当前缓存的数量，并用 volatile 修饰保证了可见性。

更多关于 volatile 的相关信息可以查看 你应该知道的 volatile 关键字

接着往下跟到：

技术图片3.png

2761 行，根据方法名称可以看出是判断当前的 Entry 是否过期，该 entry 就是通过 key 查询到的。

技术图片4.png

这里就很明显的看出是根据根据构建时指定的过期方式来判断当前 key 是否过期了。

技术图片5.png

如果过期就往下走，尝试进行过期删除（需要加锁，后面会具体讨论）。

技术图片6.png

到了这里也很清晰了：

  • 获取当前缓存的总数量
  • 自减一（前面获取了锁，所以线程安全）
  • 删除并将更新的总数赋值到 count。

其实大体上就是这个流程，Guava 并没有按照之前猜想的另起一个线程来维护过期数据。

应该是以下原因：

  • 新起线程需要资源消耗。
  • 维护过期数据还要获取额外的锁，增加了消耗。

而在查询时候顺带做了这些事情，但是如果该缓存迟迟没有访问也会存在数据不能被回收的情况，不过这对于一个高吞吐的应用来说也不是问题。

总结

最后再来总结下 Guava 的 Cache。

其实在上文跟代码时会发现通过一个 key 定位数据时有以下代码：

技术图片7.png

如果有看过 ConcurrentHashMap 的原理 应该会想到这其实非常类似。

其实 Guava Cache 为了满足并发场景的使用，核心的数据结构就是按照 ConcurrentHashMap 来的，这里也是一个 key 定位到一个具体位置的过程。

先找到 Segment，再找具体的位置，等于是做了两次 Hash 定位。

上文有一个假设是对的，它内部会维护两个队列 accessQueue,writeQueue用于记录缓存顺序，这样才可以按照顺序淘汰数据（类似于利用 LinkedHashMap 来做 LRU 缓存）。

同时从上文的构建方式来看，它也是构建者模式来创建对象的。

因为作为一个给开发者使用的工具，需要有很多的自定义属性，利用构建则模式再合适不过了。

Guava 其实还有很多东西没谈到，比如它利用 GC 来回收内存，移除数据时的回调通知等。之后再接着讨论。

 
 
 

以上是关于Guava Cache的主要内容，如果未能解决你的问题，请参考以下文章

Guava Cache 缓存工具使用

Guava Cache 缓存工具使用

guava cache 为啥删除元素时移动元素

分布式缓存系列之guava cache

Guava Cache

GUAVA CACHE(缓存) 总结