Guava学习笔记

一句话概括:缓存分为本地缓存和分布式缓存,Guava是本地缓存,而Redis是分布式缓存,Memcached自己实现为分布式缓存。

本地缓存

如 Guava、Ehcache，Guava是一个全内存的本地缓存具体实现，它提供了线程安全的实现机制。整体上来说Guava cache 是本地缓存的不二之选，简单易用，性能好。本地缓存的特点是轻量、实现简单，生命周期随着 JVM 的销毁而结束；但是如果程序存在多个实例（程序部署多套），每个实例中的缓存不具有一致性。

Guava适用性

Guava Cache 适用于:

• 你愿意消耗一些内存空间来提升速度。
• 你预料到某些键会被查询一次以上。
• 缓存中存放的数据总量不会超出内存容量。(Guava Cache 是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。如果这不符合你的需求,请尝试 Redis以及Memcached 这类工具)

Guava Cache 与 ConcurrentMap
二者很相似,但也不完全一样。最基本的区别是 ConcurrentMap 会一直保存所有添加的元素,直到显式地移除。相对地,Guava Cache 为了限制内存占用,通常都设定为自动回收元素。在某些场景下,尽管 LoadingCache 不回收元素,它也是很有用的,因为它会自动加载缓存。

Guava缓存创建

Guava Cache有两种创建方式：

• CacheLoader
• Callable

这两种创建方式有什么异同呢？

两种方式同样按照获取缓存-如果没有-则计算（get-if-absent-compute）的缓存规则对缓存数据进行的处理的。

不同之处在于：在缓存中没有得到value的时候，CacheLoader会定义一个比较宽泛的、统一的根据key值load value的方法，而Callablee的方式较为灵活，允许你在get的时候指定,看源码:

CacheLoader

public void testCacheLoader() throws ExecutionException{
    LoadingCache<String,String> cahceBuilder = CacheBuilder
            .newBuilder()
            .build(new CacheLoader<String, String>() {
                // 在load方法中定义value的加载方法；
                // 这个方法要么返回已经缓存的值,要么使用 CacheLoader 向缓存原子地加载新值
                @Override
                public String load(String key) throws Exception {
                    String strProValue="hello " + key + "!";
                    return strProValue;
                }
                
                /* 默认情况下,对每个不在缓存中的键,getAll 方法会单独调用 CacheLoader.load 来加载				   缓存项。如果批量的加载比多个单独加载更高效,你可以重载 CacheLoader.loadAll 来利					用这一点*/
                
                @Override
                public Map<String, String> loadAll(Iterable<? extends String> keys) throws Exception {
                    return super.loadAll(keys);
                }
            });
    logger.info("jerry value:"+cahceBuilder.apply("jerry"));
    logger.info(("jerry value:"+cahceBuilder.get("jerry")));
    logger.info(("peida value:"+cahceBuilder.get("peida")));
    logger.info(("peida value:"+cahceBuilder.apply("peida")));
    logger.info(("lisa value:"+cahceBuilder.apply("lisa")));
    cahceBuilder.put("harry", "ssdded");
    logger.info(("harry value:"+cahceBuilder.get("harry")));
}

异常
由于 CacheLoader 可能抛出异常,LoadingCache.get(K)也声明为抛出 ExecutionException 异常。如果你定义的 CacheLoader 没有声明任何检查型异常,则可以通过 getUnchecked(K)查找缓存;但必须注意,一旦 CacheLoader 声明了检查型异常,就不可以调用 getUnchecked(K)。

getAll(Iterable)方法
用来执行批量查询。默认情况下,对每个不在缓存中的键,getAll 方法会单
独调用 CacheLoader.load 来加载缓存项。如果批量的加载比多个单独加载更高效,你可以重载 CacheLoade
r.loadAll 来利用这一点。getAll(Iterable)的性能也会相应提升

Callable

所有类型的 Guava Cache,不管有没有自动加载功能,都支持 get(K, Callable)方法。这个方法返回缓存中相应的值,或者用给定的 Callable 运算并把结果加入到缓存中。在整个加载方法完成前,缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回;否则运算、缓存、然后返回"。

public void testCallable() throws ExecutionException{
    Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(1000).build();

    // 获取某个key时，在Cache.get中单独为其指定load方法
    String resultVal = cache.get("jerry", new Callable<String>() {
        public String call() {
            String strProValue="hello "+"jerry"+"!";
            return strProValue;
        }
    });
    logger.info("jerry value : " + resultVal);

    // 获取某个key时，在Cache.get中单独为其指定load方法
    resultVal = cache.get("peida", new Callable<String>() {
        public String call() {
            String strProValue="hello "+"peida"+"!";
            return strProValue;
        }
    });
    logger.info("peida value : " + resultVal);
}

显式插入

使用** cache.put(key, value)方法**可以直接向缓存中插入值,这会直接覆盖掉给定键之前映射的值。使用 Cache.asMap()视图提供的任何方法也能修改缓存。但请注意,asMap 视图的任何方法都不能保证缓存项被原子地加载到缓存中。进一步说,asMap 视图的原子运算在 Guava Cache 的原子加载范畴之外,所以相比于 Cache.asMap().putIfAbsent(K, V),Cache.get(K, Callable) 应该总是优先使用。

cache的参数说明：

回收的参数（这些参数在缓存回收时发挥作用）：

　1. 大小的设置：CacheBuilder.maximumSize(long) CacheBuilder.weigher(Weigher) CacheBuilder.maxumumWeigher(long)
　2. 时间：expireAfterAccess(long, TimeUnit) expireAfterWrite(long, TimeUnit)
　3. 引用：CacheBuilder.weakKeys() CacheBuilder.weakValues() CacheBuilder.softValues()
　4. 明确的删除：invalidate(key) invalidateAll(keys) invalidateAll()
　5. 删除监听器：CacheBuilder.removalListener(RemovalListener)

Guava缓存回收

一个残酷的现实是，我们几乎一定没有足够的内存缓存所有数据。你必须决定:什么时候某个缓存项就不值得保留了?Guava Cache 提供了三种基本的缓存回收方式：

• 基于容量回收
• 定时回收
• 基于引用回收

基于容量的回收(size-based eviction)

如果要规定缓存项的数目不超过固定值,只需使用CacheBuilder.maximumSize(long)。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。——警告:在缓存项的数目达到限定值之前,缓存就可能进行回收操作——通常来说,这种情况发生在缓存项的数目逼近限定值时。

LoadingCache<String,String> cahceBuilder = CacheBuilder
  .newBuilder()
  .maximumSize(10000)
  .build(new CacheLoader<String, String>() {
            ... ...
});

定时回收(Timed Eviction)

CacheBuilder 提供两种定时回收的方法:

• expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问,则回收。请注意这种缓存的回收顺序和基于大小回收一样。
• expireAfterWrite(long, TimeUnit):：缓存项在给定时间内没有被写访问(创建或覆盖),则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用,这种回收方式是可取的。
  如下文所讨论,定时回收周期性地在写操作中执行,偶尔在读操作中执行。

测试定时回收
对定时回收进行测试时,不一定非得花费两秒钟去测试两秒的过期。你可以使用 Ticker 接口和 CacheBuilder.ticker(Ticker)方法在缓存中自定义一个时间源,而不是非得用系统时钟。

基于引用的回收(Reference-based Eviction)

通过使用弱引用的键、或弱引用的值、或软引用的值,Guava Cache 可以把缓存设置为允许垃圾回收:

• CacheBuilder.weakKeys():使用弱引用存储键。当键没有其它(强或软)引用时,缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式(),使用弱引用键的缓存用而不是 equals 比较键。
• CacheBuilder.weakValues():使用弱引用存储值。当值没有其它(强或软)引用时,缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式(),使用弱引用值的缓存用而不是 equals 比较值。
• CacheBuilder.softValues():使用软引用存储值。软引用只有在响应内存需要时,才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响,我们通常建议使用更有性能预测性的缓存大小限定(见上文,基于容量回收)。使用软引用值的缓存同样用==而不是 equals 比较值。

显式清除

任何时候,你都可以显式地清除缓存项,而不是等到它被回收:

• 个别清除:Cache.invalidate(key)
• 批量清除:Cache.invalidateAll(keys)
• 清除所有缓存项:Cache.invalidateAll()

移除监听器

通过 CacheBuilder.removalListener(RemovalListener)，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，RemovalListener 会获取移除通知RemovalNotification，其中包含移除原因[RemovalCause]、键和值。

下面是一个数据库连接缓存的例子：

public void testRemovalListener(){
    class DatabaseConnection{
        // 实现省略
        DatabaseConnection(String conn){}
        void close(){}
    }
    // 创建loader
    CacheLoader<String, DatabaseConnection> loader = new CacheLoader<String, DatabaseConnection> () {
        public DatabaseConnection load(String key) throws Exception {
            return new DatabaseConnection(key);
        }
    };
    // 创建移除监听器
    RemovalListener<String, DatabaseConnection> removalListener = new RemovalListener<String, DatabaseConnection>() {
        public void onRemoval(RemovalNotification<String, DatabaseConnection> notification) {
            DatabaseConnection conn = notification.getValue();
            conn.close(); // tear down properly
        }
    };

    Cache<String, DatabaseConnection> cache = CacheBuilder.newBuilder()
            .expireAfterWrite(2, TimeUnit.MINUTES)
            .removalListener(removalListener)
            .build(loader);
}

警告：
默认情况下,监听器方法是在移除缓存时同步调用的。因为缓存的维护和请求响应通常是同时进行的,代价高昂的监听器方法在同步模式下会拖慢正常的缓存请求。在这种情况下,你可以使用 RemovalListeners.asynchronous(RemovalListener, Executor)把监听器装饰为异步操作。

缓存清理发生的时间

使用 CacheBuilder 构建的缓存不会"自动"执行清理和回收工作,也不会在某个缓存项过期后马上清理,也没有诸如此类的清理机制。相反,它会在写操作时顺带做少量的维护工作,或者偶尔在读操作时做——如果写操作实在太少的话。
这样做的原因在于:如果要自动地持续清理缓存,就必须有一个线程,这个线程会和用户操作竞争共享锁。此外,某些环境下线程创建可能受限制,这样 CacheBuilder 就不可用了。
相反,我们把选择权交到你手里。如果你的缓存是高吞吐的,那就无需担心缓存的维护和清理等工作。如果你的缓存只会偶尔有写操作,而你又不想清理工作阻碍了读操作,那么可以创建自己的维护线程,以固定的时间间隔调用 Cache.cleanUp()。ScheduledExecutorService 可以帮助你很好地实现这样的定时调度。

缓存刷新

刷新和回收不太一样。正如 LoadingCache.refresh(K)所声明,刷新表示为键加载新值,这个过程可以是异步的。在刷新操作进行时,缓存仍然可以向其他线程返回旧值,而不像回收操作,读缓存的线程必须等待新值加载完成。
如果刷新过程抛出异常,缓存将保留旧值,而异常会在记录到日志后被丢弃。

• 重载 CacheLoader.reload(K, V)可以扩展刷新时的行为,这个方法允许开发者在计算新值时使用旧的值。
• CacheBuilder.refreshAfterWrite(long, TimeUnit)可以为缓存增加自动定时刷新功能。和 expireAfterWrite相反,refreshAfterWrite 通过定时刷新可以让缓存项保持可用,但请注意:缓存项只有在被检索时才会真正刷新(如果 CacheLoader.refresh 实现为异步,那么检索不会被刷新拖慢)。因此,如果你在缓存上同时声明 expireAfterWrite 和 refreshAfterWrite,缓存并不会因为刷新盲目地定时重置,如果缓存项没有被检索,那刷新就不会真的发生,缓存项在过期时间后也变得可以回收。

Guava其他特性

统计

CacheBuilder.recordStats()用来开启 Guava Cache 的统计功能。统计打开后，Cache.stats()方法会返回 CacheStats 对象以提供如下统计信息:

• hitRate():缓存命中率;
• averageLoadPenalty():加载新值的平均时间,单位为纳秒;
• evictionCount():缓存项被回收的总数,不包括显式清除。

此外,还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的,在性能要求高的应用中我们建议密切关注这些数据。

asMap 视图

asMap 视图提供了缓存的 ConcurrentMap 形式,但 asMap 视图与缓存的交互需要注意:

• cache.asMap()包含当前所有加载到缓存的项。因此相应地，cache.asMap().keySet()包含当前所有已加载键;
• asMap().get(key)实质上等同于 cache.getIfPresent(key),而且不会引起缓存项的加载。这和 Map 的语义约定一致。
• 所有读写操作都会重置相关缓存项的访问时间,包括Cache.asMap().get(Object)方法和 Cache.asMap().put(K, V)方法,但不包括 Cache.asMap().containsKey(Object)方法,也不包括在 Cache.asMap()的集合视图上的操作。比如，遍历 Cache.asMap().entrySet()不会重置缓存项的读取时间。

Guava Cache的不足之处

• 是单个应用运行时的本地缓存，数据没有持久化存放到文件或外部服务器
• 单机缓存，受机器内存限制，重启应用缓存数据会丢失，应用分布式部署会出现缓存数据不一致的情况

__EOF__

本文作者：等不到的口琴
本文链接：https://www.cnblogs.com/Courage129/p/14413974.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！