guava cache原理解析

缓存在日常开发中举足轻重，如果你的应用对某类数据有着较高的读取频次，并且改动较小时那就非常适合利用缓存来提高性能。
谈谈 Java 中所用到的缓存，
JVM 缓存
首先是 JVM 缓存，也可以认为是堆缓存。其实就是创建一些全局变量，如 Map、List 之类的容器用于存放数据。这样的优势是使用简单但是也有以下问题：

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

Ehcache、Guava Cache
所以出现了一些专门用作 JVM 缓存的开源工具出现了，如本文提到的 Guava Cache。
它具有上文 JVM 缓存不具有的功能，如自动清除数据、多种清除算法、清除回调等。但也正因为有了这些功能，这样的缓存必然会多出许多东西需要额外维护，自然也就增加了系统的消耗。

分布式缓存
刚才提到的两种缓存其实都是堆内缓存，只能在单个节点中使用，这样在分布式场景下就招架不住了。
于是也有了一些缓存中间件，如 Redis、Memcached，在分布式环境下可以共享内存。

GuavaCache

GuavaCache 提供了一般我们使用缓存所需要的几乎所有的功能,主要有:

• 自动将entry节点加载进缓存结构中;
• 当缓存的数据已经超过预先设置的最大值时，使用LRU算法移除一些数据；
• 具备根据entry节点上次被访问或者写入的时间来计算过期机制；
• 缓存的key被封装在WeakReference引用内;
• 缓存的value被封装在WeakReference或者SoftReference引用内；
• 移除entry节点，可以触发监听器通知事件；
• 统计缓存使用过程中命中率/异常率/未命中率等数据。

Guava Cache其核心数据结构大体上和ConcurrentHashMap一致，具体细节上会有些区别。功能上，ConcurrentMap会一直保存所有添加的元素，直到显式地移除.相对地,Guava Cache为了限制内存占用,通常都设定为自动回收元素.在某些场景下,尽管它不回收元素,也是很有用的,因为它会自动加载缓存.

Guava Cache 官方推荐的使用场景：

• 愿意消耗一些内存空间来提升速度；
• 能够预计某些key会被查询一次以上；
• 缓存中存放的数据总量不会超出内存容量(Guava Cache是单个应用运行时的本地缓存)。

不管性能，还是可用性来说，Guava Cache绝对是本地缓存类库中首要推荐的工具类。其提供的Builder模式的CacheBuilder生成器来创建缓存的方式，十分方便，并且各个缓存参数的配置设置，类似于函数式编程的写法.

Guava Cache 三种方式加载到缓存中。分别是:

• LoadingCache在构建缓存的时候，使用build方法内部调用CacheLoader方法加载数据
• 在使用get方法的时候，如果缓存不存在该key或者key过期等，则调用get(K, Callable)方式加载数据；
• 使用粗暴直接的方式，直接想缓存中put数据。

demo

import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.cache.RemovalListener;
import com.google.common.cache.RemovalNotification;

/**
 * @author tao.ke Date: 14-12-20 Time: 下午1:55
 * @version \$Id$
 */
public class CacheSample {

    private static final Logger logger = LoggerFactory.getLogger(CacheSample.class);

    // Callable形式的Cache
    private static final Cache CALLABLE_CACHE = CacheBuilder.newBuilder()
            .expireAfterWrite(1, TimeUnit.SECONDS).maximumSize(1000).recordStats()
            .removalListener(new RemovalListener() {
                @Override
                public void onRemoval(RemovalNotification notification) {
                    logger.info("Remove a map entry which key is {},value is {},cause is {}.", notification.getKey(),
                            notification.getValue(), notification.getCause().name());
                }
            }).build();

    // CacheLoader形式的Cache
    private static final LoadingCache LOADER_CACHE = CacheBuilder.newBuilder()
            .expireAfterAccess(1, TimeUnit.SECONDS).maximumSize(1000).recordStats().build(new CacheLoader() {
                @Override
                public String load(String key) throws Exception {
                    return key + new Date();
                }
            });

    public static void main(String[] args) throws Exception {

        int times = 4;
        while (times-- > 0) {

            Thread.sleep(900);

            String valueCallable = CALLABLE_CACHE.get("key", new Callable() {
                @Override
                public String call() throws Exception {
                    return "key" + new Date();
                }
            });

            logger.info("Callable Cache ----->>>>> key is {},value is {}", "key", valueCallable);
            logger.info("Callable Cache ----->>>>> stat miss:{},stat hit:{}",CALLABLE_CACHE.stats().missRate(),CALLABLE_CACHE.stats().hitRate());

            String valueLoader = LOADER_CACHE.get("key");

            logger.info("Loader Cache ----->>>>> key is {},value is {}", "key", valueLoader);
            logger.info("Loader Cache ----->>>>> stat miss:{},stat hit:{}",LOADER_CACHE.stats().missRate(),LOADER_CACHE.stats().hitRate());

        }

    }
}

上述代码，简单的介绍了Guava Cache 的使用，给了两种加载构建Cache的方式。在Guava Cache对外提供的方法中， recordStats和removalListener是两个很有趣的接口，可以很好的帮我们完成统计功能和Entry移除引起的监听触发功能。

虽然在Guava Cache对外方法接口中提供了丰富的特性，但是如果我们在实际的代码中不是很有需要的话，建议不要设置这些属性，因为会额外占用内存并且会多一些处理计算工作，不值得。

Guava Cache 前置知识

Guava Cache就是借鉴Java的ConcurrentHashMap的思想来实现一个本地缓存，但是它内部代码实现的时候，还是有很多非常精彩的设计实现，

Builder模式

设计模式之 Builder模式 在Guava中很多地方得到的使用。Builder模式是将一个复杂对象的构造与其对应配置属性表示的分离，也就是可以使用基本相同的构造过程去创建不同的具体对象。
具体参照笔者的这篇Builder模式

java 对象引用

当虚拟机执行时，遇到一条new指令时，首先会去检查这个指令在常量池中是否已经存在该类对应的符号引用，并且检查这个符号引用对应的类是否已经被加载，解析和初始化。如果没有，则执行相应的类加载过程。

然后虚拟机为新的对象分配内存。虚拟机根据我们配置的垃圾收集器规则采取不同的分配方式，包括：指针碰撞分配方式和空闲列表分配方式。

内存分配完成之后，开始执行init方法。init方法会按照代码的指定过程来初始化，对一些类属性进行赋值。

然后，我们需要访问这个对象，怎么办？在Java运行时内存区域模型中，线程拥有一个虚拟机栈，这个栈会有一个本地方法表，这个表内部就会存放一个引用地址，如下图所示（HotSpot虚拟机采用这种方式，还有另外一种形式这里不做介绍）：

image.png

在JDK 1.2之前，Java中关于引用的定义是：如果reference类型的数据中存储的数值表示的是另外一块内存的起始地址，就说明这块内存称为引用。

这种定义表明对象只有两种：被引用的对象和没有被引用的对象。这种方式对于垃圾收集GC来说，效果并不是很好，因为很多对象划为为被引用和非被引用都不是很重要，这种现象就无法划分。垃圾收集的时候，就无法更好更精准的划为可GC的对象。

因此，在JDK 1.2之后，Java对引用的概念进行扩展，有如下四种类型的引用（按强度排序）：

* 强引用(Strong Reference)

* 软引用(SoftReference)

* 弱引用(WeakReference)

* 虚引用(PhantomReference)

• 强引用：强引用在程序代码中随处可见，十分普遍。比如： Object object = new Object() ，这类引用只要还存在，垃圾收集器就永远不会回收掉这类引用的对象。
• 软引用：软引用用来描述一些虽然有用但是并不是必须的对象。对于软引用关联的对象，在系统将可能发生内存溢出异常之前，垃圾收集器将会把这些引用的对象进行第二次回收。只有这次垃圾回收还没有足够的内存的时候，才会抛出内存溢出异常。
• 弱引用：弱引用是一种比软引用强度还要弱的引用，因此这些引用的对象也是非必须的。但是，对于弱引用的对象只能生存到下一次垃圾回收发生之前。当垃圾收集工作开始后，无论当前的内存是否够用，都会把这些弱引用的对象回收掉。
• 虚引用：虚引用是最弱的一种引用。一个对象是否被虚引用关联，完全不会对其生存时间构成影响，也无法通过虚引用获得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知

关于引用，最典型的使用就是对HashMap的自定义开发，包括JDK内部也存在。

• Strong Reference—> HashMap：默认情况下，HashMap使用的引用就是强引用，也就是说垃圾收集的时候，Map中引用的对象不会被GC掉。

• Weak Reference—> WeakHashMap：JDK中还有一种基于引用类型实现的HashMap，WeakHashMap。当节点的key不在被使用的时候，该entry就会被自动回收掉。因此，对于一个mapping映射，不能保证接下来的GC不会把这个entry回收掉。

• Soft Reference—> SoftHashMap：在JDK中没有提供基于软引用实现的HashMap，原因可能是一般大家都不能期待出现内存溢出，而当出现内存溢出，一点点的软引用GC余下的内存空间，肯定不会起到关键作用。但是，虽然不广泛，在aspectj提供的ClassLoaderRepository类中实现了SoftHashMap，作为一个基于ClassLoader字节码实现的方法，在OOM的时候，显然需要考虑通过GC释放内存空间，并且SoftHashMap在内部是作为缓存使用。

具体可参照笔者这篇java四种引用

JMM可见性

什么叫可见性？

可见性就是，当程序中一个线程修改了某个全局共享变量的值之后，其他使用该值的线程都可以获知，在随后他们读该共享变量的时候，查询的都是最新的改改修改的值。

一个线程上修改共享变量，这个变量的最新的值不会立刻写入到共享内存中，还是暂时存放在线程本地缓存，然后某一时刻触发写入到共享内存中。可见性就是，当我们对共享变量修改的时候，立刻把新值同步到主内存中，然后该变量被读的时候从主内存获取最新的值确保所有对该变量的读取操作，总是获取最新最近修改的值。

为什么会有可见性问题？

学过计算机组成原理的同学都知道，在现代CPU结构中，存在多级缓存架构，如下图所示：

image.png

同样，在Java虚拟机中分为两种内存：

• 主内存(Main Memory)：所有线程共享的内存区域，虚拟机内存的一部分。
• 工作内存(Working Memory)：线程自己操作的内存区域，线程直接无法访问对方的工作内存区域。

之所以分为两部分内存区域，原因和CPU很类似。为了线程可以快速访问操作变量，当线程全部直接操作共享内存，则会导致大量线程之间竞争等问题出现，影响效率。
关于Java中线程，工作内存，主内存之间的交互关系如下图

image.png

为了保证共享变量可见性，除了上篇博文中介绍的volatile之外，还有synchronized和final关键字。

synchronized：执行synchronized代码块时，在对变量执行unlock操作之前，一定会把此变量写入到主内存中。final：该关键字修饰的变量在构造函数中初始化完成之后（不考虑指针逃逸，变量初始化一半的问题），其他线程就可以看到这个final变量的值，并且由于变量不能修改，所以能确保可见性。

指令重排序

重排序通常是编译器或者运行时环境为了优化程序性能而采取的对指令进行重新排序执行的一种手段。重排序分为两类：编译期重排序和运行期重排序，分别对应编译时和运行时环境。

在运行时不同的微指令在不同的执行单元中同时执行，而且每个执行单元都全速运行。只要当前微指令所需要的数据就绪，而且有空闲的执行单元，微指令就可以立即执行，有时甚至可以跳过前面还未就绪的微指令。通过这种方式，需要长时间运行的操作不会阻塞后面的操作，流水线阻塞带来的损失被极大的减小了。

运行期JVM会对指令进行重排序以提高程序性能，当然其会通过happens-before原则保证顺序执行语义，也就是不会随便对代码指令进行重排序。

class ReorderExample {
int a = 0;
boolean flag = false;

public void writer() {
    a = 1;                   //1
    flag = true;             //2
}

Public void reader() {
    if (flag) {                //3
        int i =  a * a;        //4
        ……
    }
}
}

上述的代码会造成很多的不同结果，由于数据的可见性问题，或者就是重排序。比如重排序后执行顺序如下，则会存在问题。

image.png

可参考volatile

锁细化

这两年十分火的用于线程间通信的高性能消息组件，其虽然有很多创新的设计，但是很多优化的基本就是，锁细化，此外，在Linux内核2.6之后采用的RCU锁机制，本质上也是锁粒度细化。 在Java语言中，最经典的锁细化提高多线程并发性能的案例，就是ConcurrentHashMap，其采用多个segment，每个segment对应一个锁，来分散全局锁带来的性能损失。从而，当我们put某一个entry的时候，在实现的时候，一般只需要拥有某一个segment锁就可以完成。

关于普通的HashTable结构和ConcurrentHashMap结构，借用一张图来说明：

image.png

从结构上，可以很显而易见的看出两者的区别。所以，就锁这个层面上，concurrentHashMap就会比HashTable性能好。

Guava ListenableFuture接口

可参照ListenableFuture

CacheBuilder实现

写过Cache的，或者其他一些工具类的同学知道，为了让工具类更灵活，我们需要对外提供大量的参数配置给使用者设置，虽然这带有一些好处，但是由于参数太多，使用者开发构造对象的时候过于繁杂。

上面提到过参数配置过多，可以使用Builder模式。Guava Cache也一样，它为我们提供了CacheBuilder工具类来构造不同配置的Cache实例。但是，和本文上面提到的构造器实现有点不一样，它构造器返回的是另外一个对象，因此，这意味着在实现的时候，对象构造函数需要有Builder参数提供配置属性。

CacheBuilder构造LocalCache实现

首先，我们先看看Cache的构造函数：

/**
 * 从builder中获取相应的配置参数。 
 */

LocalCache(CacheBuilder builder, @Nullable CacheLoader loader) {
    concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

    keyStrength = builder.getKeyStrength();
    valueStrength = builder.getValueStrength();

    keyEquivalence = builder.getKeyEquivalence();
    valueEquivalence = builder.getValueEquivalence();

    maxWeight = builder.getMaximumWeight();
    weigher = builder.getWeigher();
    expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
    expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
    refreshNanos = builder.getRefreshNanos();

    removalListener = builder.getRemovalListener();
    removalNotificationQueue = (removalListener == NullListener.INSTANCE) ? LocalCache
                .> discardingQueue() : new ConcurrentLinkedQueue>();

    ticker = builder.getTicker(recordsTime());
    entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
    globalStatsCounter = builder.getStatsCounterSupplier().get();
    defaultLoader = loader;

    int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
    if (evictsBySize() && !customWeigher()) {
        initialCapacity = Math.min(initialCapacity, (int) maxWeight);
    }

    //.......
}

从构造函数可以看到，Cache的所有参数配置都是从Builder对象中获取的，Builder完成了作为该模式最典型的应用，多配置参数构建对象。

在Cache中只提供一个构造函数，但是在上面代码示例中，我们演示了两种构建缓存的方式：自动加载；手动加载。那么，一般会存在一个完成两者之间的过渡adapter组件，接下来看看Builder在内部是如何完成创建缓存对象过程的。

在LocalCache中确实提供了两种过渡类，一个是支持自动加载value的LocalLoadingCache 和只能在键值找不到的时候手动调用获取值方法的LocalManualCache。

LocalManualCache实现

  static class LocalManualCache implements Cache, Serializable {
        final LocalCache localCache;

        LocalManualCache(CacheBuilder builder) {
            this(new LocalCache(builder, null));
        }

        private LocalManualCache(LocalCache localCache) {
            this.localCache = localCache;
        }

        // Cache methods

        @Override
        @Nullable
        public V getIfPresent(Object key) {
            return localCache.getIfPresent(key);
        }

        @Override
        public V get(K key, final Callable valueLoader) throws ExecutionException {
            checkNotNull(valueLoader);
            return localCache.get(key, new CacheLoader() {
                @Override
                public V load(Object key) throws Exception {
                    return valueLoader.call();
                }
            });
        }

        //......

        @Override
        public CacheStats stats() {
            SimpleStatsCounter aggregator = new SimpleStatsCounter();
            aggregator.incrementBy(localCache.globalStatsCounter);
            for (Segment segment : localCache.segments) {
                aggregator.incrementBy(segment.statsCounter);
            }
            return aggregator.snapshot();
        }

        // Serialization Support

        private static final long serialVersionUID = 1;

        Object writeReplace() {
            return new ManualSerializationProxy(localCache);
        }
    }

从代码实现看出实际上是一个adapter组件，并且绝大部分实现都是直接调用LocalCache的方法，或者加一些参数判断和聚合。在它核心的构造函数中，就是直接调用LocalCache构造函数，对于loader对象直接设null值。

LocalLoadingCache实现
LocalLoadingCache实现继承了LocalManualCache 类，其主要对get相关方法做了重写。

static class LocalLoadingCache extends LocalManualCache implements LoadingCache {

        LocalLoadingCache(CacheBuilder builder, CacheLoader loader) {
            super(new LocalCache(builder, checkNotNull(loader)));
        }

        // LoadingCache methods

        @Override
        public V get(K key) throws ExecutionException {
            return localCache.getOrLoad(key);
        }

        @Override
        public V getUnchecked(K key) {
            try {
                return get(key);
            } catch (ExecutionException e) {
                throw new UncheckedExecutionException(e.getCause());
            }
        }

        @Override
        public ImmutableMap getAll(Iterable keys) throws ExecutionException {
            return localCache.getAll(keys);
        }

        @Override
        public void refresh(K key) {
            localCache.refresh(key);
        }

        @Override
        public final V apply(K key) {
            return getUnchecked(key);
        }

        // Serialization Support

        private static final long serialVersionUID = 1;

        @Override
        Object writeReplace() {
            return new LoadingSerializationProxy(localCache);
        }
    }
}

提供了这些adapter类之后，builder类就可以创建LocalCache，如下：

 // 获取value可以通过key计算出
   public  LoadingCache build(CacheLoader loader) {
        checkWeightWithWeigher();
        return new LocalCache.LocalLoadingCache(this, loader);
    }

    // 手动加载
    public  Cache build() {
        checkWeightWithWeigher();
        checkNonLoadingCache();
        return new LocalCache.LocalManualCache(this);
    }

CacheBuilder参数设置

CacheBuilder在为我们提供了构造一个Cache对象时，会构造各个成员对象的初始值（默认值）。了解这些默认值，对于我们分析Cache源码实现时，一些判断条件的设置原因，还是很有用的。

初始参数值设置
在ConcurrentHashMap中，我们知道有个并发水平（CONCURRENCY_LEVEL），这个参数决定了其允许多少个线程并发操作修改该数据结构。这是因为这个参数是最后map使用的segment个数，而每个segment对应一个锁，因此，对于一个map来说，并发环境下，理论上最大可以有segment个数的线程同时安全地操作修改数据结构。那么是不是segment的值可以设置很大呢？显然不是，要记住维护一个锁的成本还是挺高的，此外如果涉及全表操作，那么性能就会非常不好了。

其他一些初始参数值的设置如下所示：

 private static final int DEFAULT_INITIAL_CAPACITY = 16; // 默认的初始化Map大小
    private static final int DEFAULT_CONCURRENCY_LEVEL = 4; // 默认并发水平
    private static final int DEFAULT_EXPIRATION_NANOS = 0; // 默认超时
    private static final int DEFAULT_REFRESH_NANOS = 0; // 默认刷新时间
    static final int UNSET_INT = -1;
    boolean strictParsing = true;
    int initialCapacity = UNSET_INT;
    int concurrencyLevel = UNSET_INT;
    long maximumSize = UNSET_INT;
    long maximumWeight = UNSET_INT;
    long expireAfterWriteNanos = UNSET_INT;
    long expireAfterAccessNanos = UNSET_INT;
    long refreshNanos = UNSET_INT;

初始对象引用设置
在Cache中，我们除了超时时间，键值引用属性等设置外，还关注命中统计情况，这就需要统计对象来工作。CacheBuilder提供了初始的null 统计对象和空统计对象。

/**
     * 默认空的缓存命中统计类
     */
    static final Supplier NULL_STATS_COUNTER = Suppliers.ofInstance(new StatsCounter() {
        
        //......省略空override

        @Override
        public CacheStats snapshot() {
            return EMPTY_STATS;
        }
    });
    static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0);// 初始状态的统计对象

    /**
     * 系统实现的简单的缓存状态统计类
     */
    static final Supplier CACHE_STATS_COUNTER = new Supplier() {
        @Override
        public StatsCounter get() {
            return new SimpleStatsCounter();//这里构造简单地统计类实现
        }
    };

    /**
     * 自定义的空RemovalListener，监听到移除通知，默认空处理。
     */
    enum NullListener implements RemovalListener {
        INSTANCE;

        @Override
        public void onRemoval(RemovalNotification notification) {
        }
    }

    /**
     * 默认权重类，任何对象的权重均为1
     */
    enum OneWeigher implements Weigher {
        INSTANCE;

        @Override
        public int weigh(Object key, Object value) {
            return 1;
        }
    }

    static final Ticker NULL_TICKER = new Ticker() {
        @Override
        public long read() {
            return 0;
        }
    };

    /**
     * 默认的key等同判断
     * @return
     */
    Equivalence