google cache接口

介绍一个 google cache [本地缓存]，最近在做一些优化，优化的方面也包含了缓存，下面就先介绍一下 google cache 的 cache 接口。

Cache 接口

• 这个接口的实现应该是线程安全的，并且可以被多个并发线程安全访问

方法

getIfPresent(Object key)

• 如果这个 key 在缓存中，那么就可以通过调用该方法来命中缓存，返回返回缓存的 value
• 如果这个 key 不在缓存中，那么就无法命中缓存，那么就会返回 null

get(K key, Callable valueLoader) throws ExecutionException

• 如果 key 在缓存中命中，则通过 valueLoader 返回该缓存的 value ，且在加在完成之前该缓存的可观察状态不会被修改。
• 当加载缓存的时候，如果遇到一个受检异常，会抛出 ExecutionException
• 当加载缓存的时候，如果遇到一个非受检异常，会抛出 UncheckedExecutionException
• 当加载缓存的时候，如果遇到一个错误，会抛出 ExecutionError

getAllPresent

• 入参是一个 key 的集合，是 Iterable类型
• 返回值是一个 ImmutableMap 类型
• 该方法会返回一个与缓存中的 key 关联的 map，返回的 map 中只会包含在缓存中存在的内容

put

• 入参是缓存的 key 和 value
• 返回值是 void 类型
• 该方法会根据 key 和 value 将数据存储在缓存中，如果缓存中该 key 已经存在对应的 value,那么该 key 对应的 value 会被最新的 value 所覆盖。

putAll

• 入参是一个 map 类型
• 返回值是 void类型
• 将所有映射从指定映射复制到缓存。对于指定映射中从键到值的每个映射，此调用的效果等效于对该映射调用一次 put（k，v）的效果。如果在操作进行过程中修改了指定的映射，则此操作的行为是不确定的。

invalidate(Object key)

• 入参是缓存的 key，是一个 object 类型
• 返回值是 void 类型
• 删除该 key 对应的缓存

invalidateAll(Iterable keys)

• 入参是一个 Iterable类型，对应的是缓存的 key
• 返回值是 void类型
• 删除缓存中指定的 key 集合对应的缓存

invalidateAll()

• 没有入参
• 返回值类型是 void
• 清除缓存中的所有缓存项

size()

• 返回缓存中的缓存项的数量大小

stats()

• 没有入参
• 返回值类型是 CacheStats
• 返回此缓存的累积统计信息的当前快照。所有统计信息均初始化为零，并在缓存的整个生命周期内单调增加。

asMap()

• 没有入参
• 返回值类型是 ConcurrentMap
• 以线程安全映射的形式返回存储在此缓存中的条目的视图。对 map 的修改将直接影响缓存。
• 返回的映射中的迭代器至少是弱一致性的：它们可以安全地并发使用，但是如果在创建迭代器后修改了缓存（包括通过逐出），则尚不确定哪个更改（如果有）将反映在其中该迭代器。

cleanUp()

• 没有入参
• 返回值类型是 void 类型
• 通过执行缓存所需要的任何未决的维护操作。 究竟哪些活动执行 - 如果有的话 - 是实现相关的

package com.google.common.cache;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ExecutionError;
import com.google.common.util.concurrent.UncheckedExecutionException;

import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;

import javax.annotation.Nullable;

@Beta
@GwtCompatible
public interface Cache<K, V> {

  @Nullable
  V getIfPresent(Object key);

  V get(K key, Callable<? extends V> valueLoader) throws ExecutionException;

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

  void put(K key, V value);

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

  void invalidate(Object key);

  void invalidateAll(Iterable<?> keys);

  void invalidateAll();

  long size();

  CacheStats stats();

  ConcurrentMap<K, V> asMap();

  void cleanUp();
}