本地缓存之神-guava cache

背景

guava cache是google工具包中提供的关于本地缓存解决方案,提供了基于容量，时间和引用的缓存回收方式。
容量：利用LRU算法，
回收：Java虚拟机的垃圾回收机制（堆缓存）。

使用场景

愿意花费一部分内存来提高速度 -- 以空间换时间
期待有些关键字会被多次查询 -- 热点数据
缓存并不需要存储比RAM中更多的数据。Guava caches是一次性运行的本地缓存，并不会把数据存储到文件中或者外部服务器上 -- 不能持久化

功能

创建本地缓存

a.CacheLoader

/**
 * CacheLoader 当检索不存在的时候，会自动的加载信息的！
 */
private static LoadingCache loadingCache = CacheBuilder
        .newBuilder()
        .maximumSize(2)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .concurrencyLevel(2)
        .recordStats()
        .build(new CacheLoader() {
            @Override
            public String load(String key) throws Exception {
                String value = map.get(key);
                log.info(" load value by key; key:{},value:{}", key, value);
                return value;
            }
        });

public static String getValue(String key) {
    try {
        return loadingCache.get(key);
    } catch (Exception e) {
        log.warn(" get key error ", e);
        return null;
    }
}

b.Callable

private static Cache cacheCallable = CacheBuilder
        .newBuilder()
        .maximumSize(2)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .concurrencyLevel(2)
        .recordStats()
        .build();
/**
 * Callable 如果有缓存则返回；否则运算、缓存、然后返回
 */
public static String getValue1(String key) {
    try {
         return cacheCallable.get(key, new Callable() {
            @Override
            public String call() throws Exception {
                String value = map.get(key);
                log.info(" load value by key; key:{},value:{}", key, value);
                return value;
            }
        });
    } catch (Exception e) {
        log.warn(" get key error ", e);
        return null;
    }
}

显示插入-显示清除

public static void put(String key, String value){
    loadingCache.put(key,value); //手动添加值
}

public static void remove(String key){
    loadingCache.invalidate(key); //移除一个
    loadingCache.invalidateAll(Lists.newArrayList(key)); // 批量移除
    loadingCache.invalidateAll(); // 移除全部-清空
}

移除监听器

a.同步

private static LoadingCache loadingCache = CacheBuilder
        .newBuilder()
        .maximumSize(2)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .concurrencyLevel(2)
        .recordStats()
        .removalListener(new RemovalListener() { // sync
            @Override
            public void onRemoval(RemovalNotification removal) {
                // TODO remove notification
                log.info("loadingCache is removed. key:{},value:{}",removal.getKey(),removal.getValue());
            }
        })
        .build(new CacheLoader() {
            @Override
            public String load(String key) throws Exception {
                String value = map.get(key);
                log.info(" load value by key; key:{},value:{}", key, value);
                return value;
            }
        });

b.异步

// 创建一个监听器
private static class MyRemovalListener implements RemovalListener{
    @Override
    public void onRemoval(RemovalNotification removal) {
        // TODO remove notification
        log.info("loadingCache is removed. key:{},value:{}",removal.getKey(),removal.getValue());
    }
}

private static RemovalListener async = RemovalListeners.asynchronous(new MyRemovalListener(), Executors.newSingleThreadExecutor());

private static Cache cacheCallable = CacheBuilder
        .newBuilder()
        .maximumSize(2)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .concurrencyLevel(2)
        .recordStats()
        .removalListener(async)
        .build();

为什么使用异步，不需要解释了吧！

统计

//先开启统计
private static Cache cacheCallable = CacheBuilder
        .newBuilder()
        .maximumSize(2)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .concurrencyLevel(2)
        .recordStats()
        .removalListener(async)
        .recordStats()//开启统计
        .build();
//获取统计信息
CacheStats stats = cacheCallable.stats();
>>
public final class CacheStats {
    private final long hitCount;
    private final long missCount;
    private final long loadSuccessCount;
    private final long loadExceptionCount;
    private final long totalLoadTime;
    private final long evictionCount;
...

缓存回收方式

a. 基于容量回收
maximumSize(long)：当缓存中的元素数量超过指定值时。
b. 定时回收
expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。
expireAfterWrite(long, TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。
如下文所讨论，定时回收周期性地在写操作中执行，偶尔在读操作中执行。
c. 基于引用回收（Reference-based Eviction）
CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。
CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。
CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。

优点

线程安全的缓存，与ConcurrentMap相似，但前者增加了更多的元素失效策略，后者只能显示的移除元素。
提供了三种基本的缓存回收方式：基于容量回收、定时回收和基于引用回收。定时回收有两种：按照写入时间，最早写入的最先回收；按照访问时间，最早访问的最早回收。
监控缓存加载/命中情况。
集成了多部操作，调用get方式，可以在未命中缓存的时候，从其他地方获取数据源（DB，redis），并加载到缓存中。

缺点

Guava Cache的超时机制不是精确的；
不能持久化本地缓存；
受限于服务器的内存。

总结

那话说回来了，为什么要使用本地缓存呢？比IO更高效，比分布式缓存更稳定。