美文网首页
Google Guava Cache 详解

Google Guava Cache 详解

作者: 时之令 | 来源:发表于2019-01-11 18:47 被阅读0次

    Google Guava Cache是一种非常优秀本地缓存解决方案,提供了基于容量,时间和引用的缓存回收方式。基于容量的方式内部实现采用LRU算法,基于引用回收很好的利用了Java虚拟机的垃圾回收机制。其中的缓存构造器CacheBuilder采用构建者模式提供了设置好各种参数的缓存对象,缓存核心类LocalCache里面的内部类Segment与jdk1.7及以前的ConcurrentHashMap非常相似,都继承于ReetrantLock,还有六个队列,以实现丰富的本地缓存方案。
    本文先介绍了Guava Cache囊括的基本使用方法,然后结合体系类图和LocalCache的数据结构对典型的几个方法源码进行流程分析。

    为什么要用本地缓存

    相对于IO操作
    速度快,效率高
    相对于Redis
    Redis是一种优秀的分布式缓存实现,受限于网卡等原因,远水救不了近火。

    DB + Redis + LocalCache = 高效存储,高效访问

    image

    什么时候用

    • 愿意消耗一些内存空间来提升速度

    • 预料到某些键会被多次查询

    • 缓存中存放的数据总量不会超出内存容量

    怎么用

    1. 设置缓存容量

    2. 设置超时时间

    3. 提供移除监听器

    4. 提供缓存加载器

    5. 构建缓存

    Demo1:

    <pre style="margin: 25px 0px 0.8em; padding: 10px; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; display: block; font-size: 0.92857em; line-height: 1.3; color: rgb(51, 51, 51); word-break: break-all; overflow-wrap: break-word; border-radius: 4px; background-color: rgb(243, 243, 243); position: relative; border: none; overflow: auto; text-indent: 0px;">public class GuavaCacheDemo1 {
    public static void main(String[] args){
    CacheLoader<String, String> loader = new CacheLoader<String, String> () {
    public String load(String key) throws Exception {
    Thread.sleep(1000); if("key".equals(key)) return null;
    System.out.println(key + " is loaded from a cacheLoader!"); return key + "'s value";
    }
    };

        RemovalListener<String, String> removalListener = new RemovalListener<String, String>() {
            public void onRemoval(RemovalNotification<String, String> removal) {
                System.out.println("[" + removal.getKey() + ":" + removal.getValue() + "] is evicted!");
            }
        };
    
        LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
                .maximumSize(7)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .removalListener(removalListener)
                .build(loader);        for (int i = 0; i < 10; i ++){            String key = "key" + i;            String value = "value" + i;
            testCache.put(key,value);
            System.out.println("[" + key + ":" + value + "] is put into cache!");
        }
    
        System.out.println(testCache.getIfPresent("key6"));        try{
            System.out.println(testCache.get("key"));
        }        catch(Exception e){
            e.printStackTrace();
        }
    }
    

    }</pre>

    运行效果:

    image

    加载

    CacheLoader

    如果有合理的默认方法来加载或计算与键关联的值。

    LoadingCache是附带CacheLoader构建而成的缓存实现。创建自己的CacheLoader通常只需要简单地实现V load(K key) throws Exception方法。

    从LoadingCache查询的正规方式是使用get(K)方法。这个方法要么返回已经缓存的值,要么使用CacheLoader向缓存原子地加载新值。由于CacheLoader可能抛出异常,LoadingCache.get(K)也声明为抛出ExecutionException异常。

    Callable

    如果没有合理的默认方法来加载或计算与键关联的值,或者想要覆盖默认的加载运算,同时保留“获取缓存-如果没有-则计算”[get-if-absent-compute]的原子语义。
    所有类型的Guava Cache,不管有没有自动加载功能,都支持get(K, Callable<V>)方法。这个方法返回缓存中相应的值,或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前,缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回;否则运算、缓存、然后返回"。

    Demo2:

    <pre style="margin: 25px 0px 0.8em; padding: 10px; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; display: block; font-size: 0.92857em; line-height: 1.3; color: rgb(51, 51, 51); word-break: break-all; overflow-wrap: break-word; border-radius: 4px; background-color: rgb(243, 243, 243); position: relative; border: none; overflow: auto; text-indent: 0px;">public class GuavaCacheDemo2 { static Cache<String, String> testCache = CacheBuilder.newBuilder()
    .maximumSize(3)
    .build(); public static void main(String[] args){
    testCache.put("1234","45");

        System.out.println(testCache.getIfPresent("key6"));        try {
    
            System.out.println(testCache.get("123", new Callable<String>() {                public String call() throws Exception {                    return "134";
                }
            }));
    
            System.out.println(testCache.get("1234", new Callable<String>() {                public String call() throws Exception {                    return "134";
                }
            }));
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    

    }</pre>

    运行效果:

    image
    Cache.put

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

    缓存回收

    Guava Cache提供了三种基本的缓存回收方式:

    1. 基于容量回收

    maximumSize(long):当缓存中的元素数量超过指定值时。

    2. 定时回收

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

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

    CacheBuilder.weakKeys():使用弱引用存储键。当键没有其它(强或软)引用时,缓存项可以被垃圾回收。
    CacheBuilder.weakValues():使用弱引用存储值。当值没有其它(强或软)引用时,缓存项可以被垃圾回收。
    CacheBuilder.softValues():使用软引用存储值。软引用只有在响应内存需要时,才按照全局最近最少使用的顺序回收。

    显式清除

    任何时候,你都可以显式地清除缓存项,而不是等到它被回收:
    个别清除:Cache.invalidate(key)
    批量清除:Cache.invalidateAll(keys)
    清除所有缓存项:Cache.invalidateAll()

    移除监听器

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

    统计

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

    hitRate():缓存命中率;
    averageLoadPenalty():加载新值的平均时间,单位为纳秒;
    evictionCount():缓存项被回收的总数,不包括显式清除。
    此外,还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的,在性能要求高的应用中我们建议密切关注这些数据。

    Demo3:

    <pre style="margin: 25px 0px 0.8em; padding: 10px; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; display: block; font-size: 0.92857em; line-height: 1.3; color: rgb(51, 51, 51); word-break: break-all; overflow-wrap: break-word; border-radius: 4px; background-color: rgb(243, 243, 243); position: relative; border: none; overflow: auto; text-indent: 0px;">public class GuavaCacheDemo3 { static Cache<String, Object> testCache = CacheBuilder.newBuilder()
    .weakValues()
    .recordStats()
    .build();

    public static void main(String[] args){        Object obj1 = new Object();
    
        testCache.put("1234",obj1);
    
        obj1 = new String("123");
    
        System.gc();
    
        System.out.println(testCache.getIfPresent("1234"));
    
        System.out.println(testCache.stats());
    
    }
    

    }</pre>

    运行结果

    image

    LRU缓存回收算法

    LRU(Least?recently?used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”。

    image

    1.?新数据插入到链表头部;
    2.?每当缓存命中(即缓存数据被访问),则将数据移到链表头部;
    3.?当链表满的时候,将链表尾部的数据丢弃。

    Guava Cache中借助读写队列来实现LRU算法。

    Guava Cache体系类图

    image
    CacheBuilder

    缓存构建器。构建缓存的入口,指定缓存配置参数并初始化本地缓存。
    主要采用builder的模式,CacheBuilder的每一个方法都返回这个CacheBuilder知道build方法的调用。
    注意build方法有重载,带有参数的为构建一个具有数据加载功能的缓存,不带参数的构建一个没有数据加载功能的缓存。

    LocalManualCache

    作为LocalCache的一个内部类,在构造方法里面会把LocalCache类型的变量传入,并且调用方法时都直接或者间接调用LocalCache里面的方法。

    LocalLoadingCache

    可以看到该类继承了LocalManualCache并实现接口LoadingCache。
    覆盖了get,getUnchecked等方法。

    LocalCache

    Guava Cache中的核心类,重点了解。

    LocalCache数据结构

    根据上面的分析可知,LocalCache为Guava Cache的核心类,先看一个该类的数据结构: � LocalCache的数据结构与ConcurrentHashMap很相似,都由多个segment组成,且各segment相对独立,互不影响,所以能支持并行操作。每个segment由一个table和若干队列组成。缓存数据存储在table中,其类型为AtomicReferenceArray。

    image
    Segment<K, V>[] segments;

    Segment继承于ReetrantLock,减小锁粒度,提高并发效率。

    AtomicReferenceArray<ReferenceEntry<K, V>> table;

    类似于HasmMap中的table一样,相当于entry的容器。

    ReferenceEntry<K, V> referenceEntry;

    基于引用的Entry,其实现类有弱引用Entry,强引用Entry等

    ReferenceQueue<K> keyReferenceQueue;

    已经被GC,需要内部清理的键引用队列。

    ReferenceQueue<V> valueReferenceQueue;

    已经被GC,需要内部清理的值引用队列。

    Queue<ReferenceEntry<K, V>> recencyQueue;

    记录升级可访问列表清单时的entries,当segment上达到临界值或发生写操作时该队列会被清空。

    Queue<ReferenceEntry<K, V>> writeQueue;

    按照写入时间进行排序的元素队列,写入一个元素时会把它加入到队列尾部。

    Queue<ReferenceEntry<K, V>> accessQueue;

    按照访问时间进行排序的元素队列,访问(包括写入)一个元素时会把它加入到队列尾部。

    put

    public V put(K key, V value); //onlyIfAbsent为false
    public V putIfAbsent(K key, V value); //onlyIfAbsent为true
    该方法显式往本地缓存里面插入值。从下面的流程图中可以看出,在执行每次put前都会进行preWriteCleanUP,在put返回前如果更新了entry则要进行evictEntries操作。

    image

    preWriteCleanup

    void preWriteCleanup(long now);
    传人参数只有当前时间。
    键值引用队列中都是存储已经被GC,等待清除的entry信息,所以首先去处理这个里面的entry.
    读写队列里面是按照读写时间排序的,取出队列中的首元素,如果当前时间与该元素的时间相差值大于设定值,则进行回收。

    image

    evictEntries

    void evictEntries(ReferenceEntry<K, V> newest);
    传入的参数为最新的Entry,可能是刚插入的,也可能是刚更新过的。
    该方法只有在设置了在构建缓存的时候指定了maximumSize才会往下执行。首先清除recencyQueue,判断该元素自身的权重是否超过上限,如果超过则移除当前元素。然后判断总的权重是否大于上限,如果超过则去accessQueue里找到队首(即最不常访问的元素)进行移除,直到小于上限。

    image

    getIfPresent

    public V getIfPresent(Object key);
    该方法从本地缓存中找值,如果找不到返回null,找到就返回相应的值。

    image

    get

    首先会在缓存中找,缓存中找不到再通过load加载。

    image

    remove

    public V remove(@Nullable Object key);
    调用LocalManualCache的invalidate(Object key)方法即可调用remove.

    原文链接:https://www.jianshu.com/p/38bd5f1cf2f2

    相关文章

      网友评论

          本文标题:Google Guava Cache 详解

          本文链接:https://www.haomeiwen.com/subject/idcfdqtx.html