专栏首页程序猿人读源码——Guava-Cache

读源码——Guava-Cache

今天,听同事介绍了Cuava-cache,这是个老牌缓存了,虽然近来被Caffine的出现遮盖了风头,但依然不能掩盖它往日的辉煌,至少在我们团队,还有很多项目在使用它,索性就以它为基础,对缓存做一次总结。

名词解释

  • SoR(System-of-Record):记录系统,也就是我们的数据源,实际存储原始数据的查询速度较慢的一些介质。
  • 回源:即回到数据源头获取数据,缓存没有命中,需要去SoR读取数据,可以理解回源次数太多造成压力就是“缓存击穿”了。
  • 缓存穿透:是指缓存和数据库中都没有的数据,而用户不断发起请求,如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者,攻击会导致数据库压力过大。解决方案是:空值缓存、布隆过滤器或者布谷鸟过滤器;
  • 缓存击穿:是指缓存中没有但数据库中有的数据(一般是缓存时间到期),这时由于并发用户特别多,同时读缓存没读到数据,又同时去数据库去取数据,引起数据库压力瞬间增大,造成过大压力。解决方案是:加锁;
  • 缓存雪崩:是指缓存中数据大批量到过期时间,而查询数据量巨大,引起数据库压力过大甚至down机。和缓存击穿不同的是,缓存击穿指并发查同一条数据,缓存雪崩是不同数据都过期了,很多数据都查不到从而查数据库;

Java缓存类型

  1. 堆缓存:使用java堆来缓存对象,优点是速度很快,缺点也很明显,当缓存数据量很大时,必然会给jvm的GC带来很大压力。一般可以通过设置软引用和弱引用来存储缓存对象。堆缓存一般用于存储较热的数据。常见的实现有Cuava Cache、Ehcache 3.x、MapDB;
  2. 堆外缓存:即缓存数据存储在jvm堆外的内存中;优点是:降低了GC压力,缺点是:每次读取数据都需要对数据序列化和反序列化,速度降低了不少,可以使用Ehcache 3.x、MapDB实现;
  3. 磁盘缓存:即缓存数据存储在磁盘上,在JVM重启的时候数据也还是在的,而堆缓存/堆外缓存的数据会丢失,需要重新加载。可以使用Encache、MapDB实现;
  4. 分布式缓存:以上几个缓存都存在多实例情况下数据不一致和单机容量的问题。

回收算法

  1. FIFO (First In First Out):先进先出算法,即先放入缓存的先被移除。
  2. LRU (Least Recently Used):最近最少使用算法,使用时间距离现在最久的那个被移除。
  3. LFU (Least Frequently Used):最不常用算法,一定时间段内使用次数(频率)最少的那个被移除。

缓存使用模式

  1. Cache-Aside 即业务代码围绕缓存来写,由业务代码直接维护缓存;
  2. Cache-As-SoR 即把Cache看做 SoR,所有操作都是对Cache进行,然后Cache再委托给SoR进行真实的读/写;即业务代码中只看到Cache的操作,看不到关于SOR相关的代码。有三种实现:

① read-through:代码首先调用Cache,如果Cache不命中由Cache回源到SoR,而不是业务代码(即由Cache 读SoR)。使用Read-Through 模式,需要配置一个CacheLoader组件用来回源到SoR加载源数据.Guava Cache和Ehcache 3.x都支持该模式,下面会有实现;

② write-through:被称为穿透写模式/直写模式——代码首先调用Cache 写(新增/修改)数据,然后由Cache负责写缓存和写SoR,而不是由业务代码。使用Write-Through模式需要配置--个CacheWriter组件用来回写SoR。GuavaCache没有提供支持。Ehcache3.x支持该模式。

③ write-behind:也叫Write-Back,我们称之为回写模式。不同于Write-Through是同步写SOR和Cache,Write-Behind是异步写。异步写之后可以实现批量写、合并写、延时和限流。

Guava-Cache简单实现

public class CacheTest {
    static AtomicInteger ac = new AtomicInteger(1);
    public static LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
            .maximumSize(30000)//设置最大数量
            .expireAfterAccess(1, TimeUnit.MINUTES)//设置过期时间
            .concurrencyLevel(8)//设置并发级别
            .recordStats()
            .weakKeys()//key value均设置为弱引用
            .weakValues()
            .refreshAfterWrite(30, TimeUnit.SECONDS)//刷新时间
            .build(new CacheLoader<String, String>() {
                @Override
                public String load(String s) throws Exception {
                    return s + ac.getAndIncrement();
                }
            });

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println(testCache.get("test"));
        System.out.println(testCache.get("test"));
        TimeUnit.SECONDS.sleep(30);
        System.out.println(testCache.get("test"));
        TimeUnit.SECONDS.sleep(30);
        System.out.println(testCache.get("test"));
    }
}

运行结果

"C:\Program Files\Java\jdk1.8.0_221\bin\java.exe"...
test1
test1
test2
test3

Process finished with exit code 0

源码解读(基于实现)

CacheBuilder基于建造者模式完成对LocalCache.LocalLoadingCache的构建。LocalCache继承于ConcurrentMap,散列表由Segment[]数组作为主体,采用AtomicReferenceArray完成Hash碰撞时候的扩展,是线程安全的。然后重点看一下它的get实现。调用栈为:

testCache.get("test")
=>LocalCache#LocalLoadingCache#get(K key)
=>LocalCache#getOrLoad(K key)
=>LocalCache#get(K key, CacheLoader<? super K, V> loader)//获取对应的segement
=>Segement#get(K key, int hash, CacheLoader<? super K, V> loader)
V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
  checkNotNull(key);
  checkNotNull(loader);
  try {
    if (count != 0) { // 判断当前segement下有没有值
      ReferenceEntry<K, V> e = getEntry(key, hash);// 如果有值,就循环获取;
      if (e != null) {
        long now = map.ticker.read();//获取系统时间
        V value = getLiveValue(e, now);//判断是否过期
        if (value != null) {
          recordRead(e, now);// 更新当前的访问时间
          statsCounter.recordHits(1);//命中计数
          return scheduleRefresh(e, key, hash, value, now, loader);//刷新
        }
        ValueReference<K, V> valueReference = e.getValueReference();
        if (valueReference.isLoading()) {//如果是其他线程正在加载,就等待再返回
          return waitForLoadingValue(e, key, valueReference);
        }
      }
    }
    return lockedGetOrLoad(key, hash, loader);//重新加载
  } catch (ExecutionException ee) {
    Throwable cause = ee.getCause();
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    } else if (cause instanceof RuntimeException) {
      throw new UncheckedExecutionException(cause);
    }
    throw ee;
  } finally {
    postReadCleanup();
  }
}

这个方法主要用于处理缓存值得过期和刷新。这涉及到三个参数:

  • expireAfterAccess: 当缓存项在指定的时间段内没有被读或写就会被回收。
  • expireAfterWrite:当缓存项在指定的时间段内没有更新就会被回收。
  • refreshAfterWrite:当缓存项上一次更新操作之后的多久会被刷新。

优化思路:

expireAfterAccess失效性太差,如果一直存在读或者写的话,缓存可能永远不会被更新。而expireAfterWrite则通过一个加锁的方式,只允许一个线程去回源,有效防止了缓存击穿。但是,可以预见的是,而且当一个线程在回源的时候,其他请求同样key的线程一部分处于一个阻塞等待的过程(waitForLoadingValue),一部分在双重加锁处等待,可以说有一些性能损耗;如果使用refreshAfterWrite,缓存值会通过scheduleRefresh(e, key, hash, value, now, loader)加载,同样保证了只有一个缓存能进入,其他缓存没有阻塞,而是使用原值。这样虽然保证了性能,但是如果某个key吞吐量低,它使用到的旧值很可能是很久之前的,不大友好。通过源码,可以看到,如果同时使用expireAfterWrite和refreshAfterWrite的话,refreshAfterWrite<expireAfterWrite,这样当最先触发refreshAfterWrite的时候,采用刷新机制,不至于带来大氛围线程阻塞,当再触发expireAfterWrite的时候,没有来得及刷新的会被置位过期(刷新会重置writeTIme)。这就有点redis惰性删除和主动删除配合的意思了,另外在软引用和弱引用的使用,可以把缓存调整到最佳状态。软引用和弱引用

 V lockedGetOrLoad(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
  ReferenceEntry<K, V> e;
  ValueReference<K, V> valueReference = null;
  LoadingValueReference<K, V> loadingValueReference = null;
  boolean createNewEntry = true;

  lock();
  try {
    // re-read ticker once inside the lock
    long now = map.ticker.read();
    preWriteCleanup(now);

    int newCount = this.count - 1;
    AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
    int index = hash & (table.length() - 1);
    ReferenceEntry<K, V> first = table.get(index);

    for (e = first; e != null; e = e.getNext()) {
      K entryKey = e.getKey();
      if (e.getHash() == hash
          && entryKey != null
          && map.keyEquivalence.equivalent(key, entryKey)) {
        valueReference = e.getValueReference();
        if (valueReference.isLoading()) {
          createNewEntry = false;
        } else {
          V value = valueReference.get();
          if (value == null) {
            enqueueNotification(
                entryKey, hash, value, valueReference.getWeight(), RemovalCause.COLLECTED);
          } else if (map.isExpired(e, now)) {
            enqueueNotification(
                entryKey, hash, value, valueReference.getWeight(), RemovalCause.EXPIRED);
          } else {
            recordLockedRead(e, now);
            statsCounter.recordHits(1);
            return value;
          }
          writeQueue.remove(e);//写队列
          accessQueue.remove(e);//读队列
          this.count = newCount; // write-volatile
        }
        break;
      }
    }

    if (createNewEntry) {
      loadingValueReference = new LoadingValueReference<K, V>();

      if (e == null) {
        e = newEntry(key, hash, first);
        e.setValueReference(loadingValueReference);
        table.set(index, e);
      } else {
        e.setValueReference(loadingValueReference);
      }
    }
  } finally {
    unlock();
    postWriteCleanup();
  }

  if (createNewEntry) {
    try {
      synchronized (e) {
        return loadSync(key, hash, loadingValueReference, loader);
      }
    } finally {
      statsCounter.recordMisses(1);
    }
  } else {
    return waitForLoadingValue(e, key, valueReference);
  }
}

这是Guava-Cache实现的加载类,采用ReentrantLock完成加锁,使整个map实现一个分段锁的结构。另外,整体对future的使用灰常值得借鉴。

以上。。。

本文分享自微信公众号 - 程序猿人(caoyusong1991),作者:早安嵩骏

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-10-29

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Raw use of parameterized class 'Future'

    警告:Raw use of parameterized class 'Future' Inspection info: Reports any uses of ...

    早安嵩骏
  • 死磕Reactor模式

    上两篇从I/O模型讲到了I/O多路复用器。这一篇主要总结下I/O多路复用器的主要应用——Reactor模式。

    早安嵩骏
  • Linux--nc命令

    我们常常会面临服务器和本地机器之间的文件传输,通常情况下,lszrz命令是可以完全应付的。但是当文件过大的时候,例如前段时间需要传输一个1.7G的堆dump文件...

    早安嵩骏
  • GuavaCache 简单入门

    缓存在各种用例中非常有用。尤其是当计算或者检索的代价很高,而需要多次在输入上检索这个值得时候,应该使用缓存。

  • Google Guava Cache 使用

    缓存在很多场景下都是相当有用的。例如,计算或检索一个值的代价很高,并且对同样的输入需要不止一次获取值的时候,就应当考虑使用缓存。

    MickyInvQ
  • SpringBoot 整合 Cacheable

    本文由 Alone88 创作,采用 知识共享署名4.0 国际许可协议进行许可 本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名 最后编辑时间为...

    Alone88
  • 性能设计 - 缓存

    基本上来说,在分布式系统中最耗性能的地方就是最后端的数据库了。一般来说,只要小心维护好,数据库四种操作(select、update、insert 和 delet...

    JAVA日知录
  • 【专业知识】Android中的磁盘缓存

    前言: 在上一篇文章中介绍了内存缓存,内存缓存的优点就是很快,但是它又有缺点: 空间小,内存缓存不可能很大; 内存紧张时可能被清除; 在应用退出时就会消失,做不...

    程序员互动联盟
  • ASP.NET 缓存(3)

    有2种方式来实现缓存部分页。 片段缓存:这种情况下,你把确定要缓存的内容,包裹在一个专用的用户控件里,然后只需要对这个控件做输出缓存就行。 post-c...

    py3study
  • Spring Cache 缺陷,我好像有解决方案了

    在 for 循环中操作 redis。如果数据命中缓存还好,一旦缓存没有命中,则会访问数据库。

    Coder小黑

扫码关注云+社区

领取腾讯云代金券