1. cache 接口
   主要有这几个方法 :

   • V getIfPresent(Object var1);

   • V get(K var1, Callable<? extends V> var2) throws ExecutionException;

   • ImmutableMap<K, V> getAllPresent(Iterable<?> var1);

   • void put(K var1, V var2);

   • void putAll(Map<? extends K, ? extends V> var1);

   • void invalidate(Object var1);

   • void invalidateAll(Iterable<?> var1);

   • void invalidateAll();

   • long size();

   • CacheStats stats();

   • ConcurrentMap<K, V> asMap();

   • void cleanUp();

AbstractCache 是个抽象类 ，继承了Cache

1. 如果调用AbstractCache的get、put、size、invalidate、invalidateAll()、stats()、asMap()方法，会抛出UnsupportedOperationException()异常。
2. getAllPresent 返回的ImmutableMap为LinkedHashMap。
   当插入一串新数据时，会首先判断是否当前插入的是否存在于之前已经插入的数据中 ，如果不存在，继续判断是否已经当前对象中 ，如果不是，就插入结果集合。最后返回结果集合 。
3. invalidateAll(Iterable<?> keys)，调用invalidate删除数据
4. 里面有一个SimpleStatsCounter内部类 ，实现了AbstractCache.StatsCounter接口。
   同时定义了一个LongAddable 接口。
   statsCounter 接口
   public interface StatsCounter
   {
   void recordHits(int var1);
   void recordMisses(int var1);
   void recordLoadSuccess(long var1);
   void recordLoadException(long var1);
   void recordEviction();
   CacheStats snapshot();
   }
   LongAddable 接口
   interface LongAddable
   {
   void increment();
   void add(long var1);
   long sum();
   }
   SimpleStateCounter中定义了一系列LongAddAble操作。包括命中计数、未命中计数、装载成功计数、装载异常计数、总共装载计数、换出计数。（
   long hitCount, long missCount, long loadSuccessCount, long loadExceptionCount, long totalLoadTime, long evictionCount）
   snapshot()函数将返回当前所有计数的数量。
   incrementBy(AbstractCache.StatsCounter other)可以直接在一系列的计数中加上另外一个AbstractCache.StatsCounter的数量。

AbstractLoadingCache是个抽象类，继承了AbstractCache.

CacheBuilder
在cacheBuilder的文档中提到，一个LoadingCache和Cache的实例的构造者应该具有以下特点：
A builder　of LoadingCache and Cache instances having any combination of the following features:

• automatic loading of entries into the cache
• least-recently-used eviction when a maximum size is exceeded
• time-based expiration of entries, measured since last access or last write
• keys automatically wrapped in [weak]references
• values automatically wrapped in [weak] or [soft] references
• notification of evicted (or otherwise removed) entries
• accumulation of cache access statistics

中文翻译就是

• 自动装载实体到内存。
• 当超过最大内存时，会清除最近最少使用的。
• 按照上次访问或写入的时间来测量条目是否达到过期时间。
• 键自动包裹在弱引用中。
• 值自动包裹到强引用或软引用中。
• 删除或换出数据时有通知
• 积累缓存访问的数据

These features are all optional; caches can be created using all or none of them. By default cache instances created by CacheBuilder will not perform any type of eviction.

这些功能都是可选的;可以使用全部或不创建高速缓存。默认情况下，CacheBuilder创建的缓存实例不会执行任何类型的逐出。
一个使用cachebuilder的实例：

  LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
   .maximumSize(10000)
   .expireAfterWrite(10, TimeUnit.MINUTES)
   .removalListener(MY_LISTENER)
   .build(
       new CacheLoader<Key, Graph>() {
         public Graph load(Key key) throws AnyException {
           return createExpensiveGraph(key);
         }
       });　

还有一种创建方式

    String spec = "maximumSize=10000,expireAfterWrite=10m";
     LoadingCache<Key, Graph> graphs = CacheBuilder.from(spec)
   　.removalListener(MY_LISTENER)
   　.build(
       new CacheLoader<Key, Graph>() {
         public Graph load(Key key) throws AnyException {
           return createExpensiveGraph(key);
         }
       });

这两种创建方式是等价的。

The returned cache is implemented as a hash table with similar performance characteristics to ConcurrentHashMap
. It implements all optional operations of the LoadingCache and Cache interfaces. The asMap
view (and its collection views) have weakly consistent iterators. This means that they are safe for concurrent use, but if other threads modify the cache after the iterator is created, it is undefined which of these changes, if any, are reflected in that iterator. These iterators never throw ConcurrentModificationException
.

大概意思如下：

1. 返回的cache的实现类似于ConcurrentHashMap的哈希表。
   它实现了LoadingCache和Cache的所有接口。
2. asMap视图是弱一致的迭代器。这意味着他们是线程安全的。它没有定义这些改变，当影响到迭代器时，这些迭代器绝不会抛出ConcurrentModificationException异常。
3. 已经换出的数据也可能被Cache.size()方法在计数时计算，但是不能对其进行读写操作。
4. CacheBuilder<K,V> maximumWeight(long weight)这个方法确定了缓存包含的对象的最大权重。
   注意权重只是用来决定缓存是否已经超过其最大容量。它对于接下来要将哪个对象换出内存没有影响。
   抛出的异常

• IllegalArgumentException假如设置的权值为负
• IllegalStateException假如已经设置了最大权重或者最大容量