1. 前言

互联网软件神速发展，用户的体验度是判断一个软件好坏的重要原因，所以缓存就是必不可少的一个神器。在多线程高并发场景中往往是离不开cache的，需要根据不同的应用场景来需要选择不同的cache，比如分布式缓存如redis、memcached，还有本地（进程内）缓存如ehcache、GuavaCache、Caffeine。

说起Guava Cache，很多人都不会陌生，它是Google Guava工具包中的一个非常方便易用的本地化缓存实现，基于LRU算法实现，支持多种缓存过期策略。由于Guava的大量使用，Guava Cache也得到了大量的应用。但是，Guava Cache的性能一定是最好的吗？也许，曾经，它的性能是非常不错的。但所谓长江后浪推前浪，总会有更加优秀的技术出现。今天，我就来介绍一个比Guava Cache性能更高的缓存框架：Caffeine。

2. 比较

Google Guava工具包中的一个非常方便易用的本地化缓存实现，基于LRU算法实现，支持多种缓存过期策略。

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

Caffeine是使用Java8对Guava缓存的重写版本，在Spring Boot 2.0中将取代，基于LRU算法实现，支持多种缓存过期策略。

2.1 官方性能比较

场景1：8个线程读，100%的读操作

场景二：6个线程读，2个线程写，也就是75%的读操作，25%的写操作

 

场景三：8个线程写，100%的写操作

可以清楚的看到Caffeine效率明显的高于其他缓存。

3. 如何使用

3.1手动加载（Manual）

public static void main(String[] args) {
        Cache<String, String> manualCache = Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MILLISECONDS)   //设置过期时间
                .maximumSize(100)    //设置最大缓存个数
                .build();
        String key = "name";
        // 根据key查询一个缓存，如果没有返回NULL
        String value = manualCache.getIfPresent(key);
        System.out.println("key "+ value);    //key null
        // 将一个值放入缓存，如果以前有值就覆盖以前的值
        manualCache.put(key,"reed");
        String value1 = manualCache.getIfPresent(key);
        System.out.println("key1 "+value1);   //key1 reed
        // 删除一个缓存
        manualCache.invalidate(key);
        String value2 = manualCache.getIfPresent(key);
        System.out.println("key2 "+value2);    //key2 null
        // 根据Key查询一个缓存，如果没有调用createExpensiveGraph方法，并将返回值保存到缓存。
        String value3 =manualCache.get(key,k->"fan");
        System.out.println("key3 "+value3);    //key3 fan
        String value4 = manualCache.get(key,k->"reed");
        System.out.println("key4 "+value4);    //key4 fan
    }

3.2同步加载（Loading）

@Test
    public void test(){
        LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
                .maximumSize(10_000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(key -> getName(key));

        List<String> keys = new ArrayList<>();
        keys.add("reed");
        keys.add("fan");

        Map<String,String> map = loadingCache.getAll(keys);

        for(Map.Entry<String,String> m:map.entrySet()){
            System.out.println("key:" + m.getKey() + " value:" + m.getValue());
            /*key:reed value:reed
            key:fan value:fan*/
        }
    }
    private String getName(String str){
        return str;
    }

3.3异步加载（Asynchronously Loading）

@Test
    public void test() throws Exception {
        AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
                .maximumSize(10_000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .buildAsync(key -> getName(key));

        List<String> keys = new ArrayList<>();
        keys.add("reed");
        keys.add("fan");
        CompletableFuture<Map<String, String>> names = asyncLoadingCache.getAll(keys);
        Map<String, String> map = names.get();

        for (Map.Entry<String, String> m : map.entrySet()) {
            System.out.println("key:" + m.getKey() + " value:" + m.getValue());
            /*key:reed value:reed
            key:fan value:fan*/
        }
    }

    private String getName(String str) {
        return str;
    }