Guava Cache源码浅析

1. 简介

Guava Cache是指在JVM的内存中缓存数据,相比较于传统的数据库或redis存储,访问内存中的数据会更加高效,无网络开销。

根据Guava官网介绍,下面的这几种情况可以考虑使用Guava Cache:

1. 愿意消耗一些内存空间来提升速度。

2. 预料到某些键会被多次查询。

3. 缓存中存放的数据总量不会超出内存容量。

因此,Guava Cache特别适合存储那些访问量大、不经常变化、数据量不是很大的数据,以改善程序性能。

2. 类图

 

Guava Cache的类图中,主要涉及了5个类:CacheBuilder、LocalCache、Segment、EntryFactory和ReferenceEntry,大部分业务逻辑都在前面三个类,依次介绍如下:

2.1 CacheBuilder

CacheBuilder是一个用于构建Cache的类,是建造者模式的一个例子,主要的方法有:

  • maximumSize(long maximumSize): 设置缓存存储的所有元素的最大个数。
  • maximumWeight(long maximumWeight): 设置缓存存储的所有元素的最大权重。
  • expireAfterAccess(long duration, TimeUnit unit): 设置元素在最后一次访问多久后过期。
  • expireAfterWrite(long duration, TimeUnit unit): 设置元素在写入缓存后多久过期。
  • concurrencyLevel(int concurrencyLevel): 设置并发水平,即允许多少线程无冲突的访问Cache,默认值是4,该值越大,LocalCache中的segment数组也会越大,访问效率越高,当然空间占用也大一些。
  • removalListener(RemovalListener<? super K1, ? super V1> listener): 设置元素删除通知器,在任意元素无论何种原因被删除时会调用该通知器。
  • setKeyStrength(Strength strength): 设置元素的key是强引用,还是弱引用,默认强引用,并且该属性也指定了EntryFactory使用是强引用还是弱引用。
  • setValueStrength(Strength strength) : 设置元素的value是强引用,还是弱引用,默认强引用。

2.2 LocalCache

 LocalCache是一个支持并发访问的Hash Map,它实现了ConcurrentMap,其内部会持有一个segment数组,元素的增删改查都是通过调用segment的对应方法来实现的,

其主要的方法有:

  • get(Object key): 查询一个key,内部实现是调用了Segment的get方法。
  • public V put(K key, V value): 添加一个对象到cache中,内部实现是调用了Segment的put方法。
  • remove(Object key) : 删除一个key,内部实现是调用了Segment的remove方法。
  • replace(K key, V value):更新一个key,内部实现是调用了Segment的update方法。

2.3 Segment

 segment是实际元素的持有者,它内部持有一个table数组,数组的每个元素又对应一个链表,链表上则保存了实际的元素,它的主要方法对应LocalCache提供的增删改查的接口,这里就不再啰嗦了。

2.4 EntryFactory

 EntryFactory是entry的创建工厂,可支持创建强引用、弱引用、强读引用、强写引用、强读写引用、弱读引用、弱写引用、弱读写引用等类型的元素。

强引用和弱引用就是java四种引用类型里面的强弱引用,默认是强引用,而读引用是指创建的元素会记录最后一次的访问时间,如果用户在CahceBuilder中调用了expireAfterAccess或者maximumWeight则会使用读引用类型的工厂,写引用类型也是同样的逻辑。

2.5 ReferenceEntry

 ReferenceEntry是元素的接口定义,它的实现类就是EntryFactory中创建的元素,包含了8种类型的元素,元素中至少包含了key、value和hash三个字段,其中hash是当前元素的hash值,如果是读引用则会多一个accessTime字段,以强引用的构造方法为例:

static class StrongEntry<K, V> extends AbstractReferenceEntry<K, V> {
    final K key;

    StrongEntry(K key, int hash, @Nullable ReferenceEntry<K, V> next) {
      this.key = key;
      this.hash = hash;
      this.next = next;
    }

    @Override
    public K getKey() {
      return this.key;
    }

    // The code below is exactly the same for each entry type.

    final int hash;
    final @Nullable ReferenceEntry<K, V> next;
    volatile ValueReference<K, V> valueReference = unset();

 

强读引用的代码如下:

 StrongAccessEntry(K key, int hash, @Nullable ReferenceEntry<K, V> next) {
      super(key, hash, next); // 继承了StrongEntry,并多了accessTime
    }

    // The code below is exactly the same for each access entry type.

    volatile long accessTime = Long.MAX_VALUE;

2.6 LocalCache示例

上面对LoacheCache所涉及的主要的类都做了介绍,下面画一张示例图给个直观感受,该例子中的Cache中包含的segment数组大小为4(默认值是4),第二个segment的table数组大小为4,其中第二个table中的链表中有3个元素(简便起见,其他segment和table中的元素就不画了),

 

 

3. 主要方法

上面介绍了几个主要的类,下面从使用者的角度来把这几个类串联起来,主要包含了:创建Cache、添加对象、访问对象和删除对象。

3.1 创建Cache

 创建一个Cache的实现代码如下:

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
      .maximumSize(10000) // 最大元素个数
      .expireAfterWrite(Duration.ofMinutes(10)) // 元素写入10分钟后期
      .removalListener(MY_LISTENER)  // 自定义的一个监听器
      .build(
          new CacheLoader<Key, Graph>() {  // 元素加载器,当查询元素不存在时,会自动调用该方法进行加载,然后再返回元素
            public Graph load(Key key) throws AnyException {
              return createExpensiveGraph(key);
            }
         });
 }

 

3.2 添加元素

添加元素访问的是LocalCache的put方法(注意这个方法是没有锁的),代码如下:

@Override
  public V put(K key, V value) {
    checkNotNull(key);
    checkNotNull(value);
    int hash = hash(key);   // 首先计算key的hash值,并根据hash选定segment,再调用segment的put方法
    return segmentFor(hash).put(key, hash, value, false);
  }

/**
   * Returns the segment that should be used for a key with the given hash.
   *
   * @param hash the hash code for the key
   * @return the segment
   */
  Segment<K, V> segmentFor(int hash) {
    // 
    return segments[(hash >>> segmentShift) & segmentMask];
  }

再看下segment中的put方法(注意这个方法是有锁的):

@Nullable
    V put(K key, int hash, V value, boolean onlyIfAbsent) {
      lock();  // 一开始先加锁
      try {
        long now = map.ticker.read(); // 当前时间,单位纳秒
        preWriteCleanup(now); // 删除过期元素

        int newCount = this.count + 1;
        if (newCount > this.threshold) { // 必要时先扩容
          expand();
          newCount = this.count + 1;
        }

        //  根据hash再定位在table中的位置
        AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
        int index = hash & (table.length() - 1);
        // 取得table中对应位置的链表的首个元素
        ReferenceEntry<K, V> first = table.get(index);

        // 遍历该链表,如果已在链表中则更新值.
        for (ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
          K entryKey = e.getKey();
          if (e.getHash() == hash
              && entryKey != null
              && map.keyEquivalence.equivalent(key, entryKey)) {
            // We found an existing entry.

            ValueReference<K, V> valueReference = e.getValueReference();
            V entryValue = valueReference.get();

            if (entryValue == null) {
              ++modCount;
              if (valueReference.isActive()) {
                enqueueNotification(
                    key, hash, entryValue, valueReference.getWeight(), RemovalCause.COLLECTED);
                setValue(e, key, value, now);
                newCount = this.count; // count remains unchanged
              } else {
                setValue(e, key, value, now);
                newCount = this.count + 1;
              }
              this.count = newCount; // write-volatile
              evictEntries(e);
              return null;
            } else if (onlyIfAbsent) {
              // Mimic
              // "if (!map.containsKey(key)) ...
              // else return map.get(key);
              recordLockedRead(e, now);
              return entryValue;
            } else {
              // clobber existing entry, count remains unchanged
              ++modCount;
              enqueueNotification(
                  key, hash, entryValue, valueReference.getWeight(), RemovalCause.REPLACED);
              setValue(e, key, value, now);
              evictEntries(e);
              return entryValue;
            }
          }
        }

        // 在链表中未找到,则创建一个新的元素,并添加在链表的头部,即2.6章节示例中的table[1]和entry1之间.
        ++modCount;// 链表更新操作次数加1
        ReferenceEntry<K, V> newEntry = newEntry(key, hash, first);
        setValue(newEntry, key, value, now);
        table.set(index, newEntry);// 添加到链表头部
        newCount = this.count + 1;
        this.count = newCount; // segment内的元素个数加1
        evictEntries(newEntry);
        return null;
      } finally {
        unlock();
        postWriteCleanup(); // 前面删除元素时,会把删除通知加入到队列中,在这里遍历删除通知队列并发出通知
      }
    }

添加方法的代码如上所示,重点有两个地方:

1. LocalCache的put方法中是不加锁的,而Segment中的put方法是加锁的,因此在访问量很大的时候,可以通过提高concurrencyLevel的值来提高segment数组大小,减少锁冲突。

2. 在执行put方法时,会“顺便”执行清理操作,删除过期的元素,因为Guava Cache没有后台线程,因此删除操作是在每次的put操作和一定次数的read操作时执行的,且清理的是当前segment的过期元素,这也告诉我们过期的元素并不是立即被删除的,即内存不是立即释放的,会随着我们的读写操作来释放的,当然如果Guava Cache本身访问量不大,导致累积了大量过期元素后,再来访问可能会有较大的访问耗时

3.3 访问元素

 访问元素访问的是LocalCache的get方法(注意这个方法是没有锁的),代码如下:

public @Nullable V getIfPresent(Object key) {
// 和put一样,先对key做hash,再定位segment,然后调用get访问
int hash = hash(checkNotNull(key)); V value = segmentFor(hash).get(key, hash); if (value == null) { globalStatsCounter.recordMisses(1); } else { globalStatsCounter.recordHits(1); } return value; }

继续看segment的get方法(注意这个方法是没有锁的):

@Nullable
    V get(Object key, int hash) {
      try {
        if (count != 0) { // read-volatile
          long now = map.ticker.read();
         // 查询存活的元素
          ReferenceEntry<K, V> e = getLiveEntry(key, hash, now);
          if (e == null) {
            return null;
          }

          V value = e.getValueReference().get();
          if (value != null) {
            recordRead(e, now);
            // 检查是否需要刷新元素
            return scheduleRefresh(e, e.getKey(), hash, value, now, map.defaultLoader);
          }
         // 删除非强引用的队列,包含key队列和value队列
          tryDrainReferenceQueues();
        }
        return null;
      } finally {
        postReadCleanup();// 检查是否有过期元素待删除
      }
    }

下面再看下getLiveEntry和postReadCleanup方法:

@Nullable
    ReferenceEntry<K, V> getLiveEntry(Object key, int hash, long now) {
      ReferenceEntry<K, V> e = getEntry(key, hash);
      if (e == null) {
        return null;
      } else if (map.isExpired(e, now)) { // 检查元素是否过期
        tryExpireEntries(now);
        return null;
      }
      return e;
    }
@Nullable
    ReferenceEntry<K, V> getEntry(Object key, int hash) {
      // 根据hash定位table中位置的链表,并进行遍历,检查hash是否相等
      for (ReferenceEntry<K, V> e = getFirst(hash); e != null; e = e.getNext()) {
        if (e.getHash() != hash) {
          continue;
        }

        K entryKey = e.getKey();
        if (entryKey == null) { // 被垃圾回收期回收,清理引用队列
          tryDrainReferenceQueues();
          continue;
        }

        if (map.keyEquivalence.equivalent(key, entryKey)) {
          return e;
        }
      }

      return null;
    }

    /** Returns first entry of bin for given hash. */
    ReferenceEntry<K, V> getFirst(int hash) {
      // read this volatile field only once 
      AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
      return table.get(hash & (table.length() - 1));
    }

 
void postReadCleanup() {
     // DRAIN_THRESHOLD=63,即每读64次会执行一次清理操作
      if ((readCount.incrementAndGet() & DRAIN_THRESHOLD) == 0) {
        cleanUp();
      }
    }

读方法相对要简单一些,重点有两个地方:

1. 查找到元素后检查是否过期,过期则删除,否则返回。

2. put方法每次调用都执行清理方法,get方法每调用64次get方法,才会执行一次清理。

注意,前面示例中的CacheBuilder创建LocalCache时,添加了元素加载器,当get方法中发现元素不存在时

 

3.4 删除元素

 删掉元素是invalidate()接口,该接口最终调用了segment的remove方法实现,如下:

V remove(Object key, int hash) {
      lock();  // 和put有些类似,先加锁,再搜索,然后从链表删除
      try {
        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 (ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
          K entryKey = e.getKey();
          if (e.getHash() == hash
              && entryKey != null
              && map.keyEquivalence.equivalent(key, entryKey)) {
            ValueReference<K, V> valueReference = e.getValueReference();
            V entryValue = valueReference.get();

            RemovalCause cause;
            if (entryValue != null) {
              cause = RemovalCause.EXPLICIT;
            } else if (valueReference.isActive()) {
              cause = RemovalCause.COLLECTED;
            } else {
              // currently loading
              return null;
            }

            ++modCount;
            // 删除方法有些特别,看下面分析
            ReferenceEntry<K, V> newFirst =
                removeValueFromChain(first, e, entryKey, hash, entryValue, valueReference, cause);
            newCount = this.count - 1;
            table.set(index, newFirst);
            this.count = newCount; // write-volatile
            return entryValue;
          }
        }

        return null;
      } finally {
        unlock();
        postWriteCleanup();
      }
    }

// removeValueFromChain调用了removeEntryFromChain
@GuardedBy("this")
    @Nullable
    ReferenceEntry<K, V> removeEntryFromChain(
        ReferenceEntry<K, V> first, ReferenceEntry<K, V> entry) {
      int newCount = count;
      ReferenceEntry<K, V> newFirst = entry.getNext();
     // 删除元素时,没有直接从链表上面摘除,而是遍历first和entry之间的元素,并拷贝新建新的元素构建链表
      for (ReferenceEntry<K, V> e = first; e != entry; e = e.getNext()) {
        ReferenceEntry<K, V> next = copyEntry(e, newFirst);
        if (next != null) {
          newFirst = next;
        } else {
          removeCollectedEntry(e);
          newCount--;
        }
      }
      this.count = newCount;
      return newFirst;
    }

注意删除的时候,并没有直接从链表摘除,而是做了一次遍历新建了一个链表,举个例子:

 为什么要做一次遍历呢?先看一下StrongEntry的定义:

static class StrongEntry<K, V> extends AbstractReferenceEntry<K, V> {
    final K key;
    final int hash;
    final @Nullable ReferenceEntry<K, V> next;
    volatile ValueReference<K, V> valueReference = unset();
}

key,hash和next都是final的,通过这种新建链表的方式,可以保证当前的并发读线程是能读到数据的(读方法无锁),即使是过期的,这其实就是CopyOnWrite的思想。

4. 小结

从上面分析可以看出,guava cache是一款非常优秀的本地缓存组件,为了得到更好的效率,减少写操作锁冲突(读操作无锁),可以将concurrencyLevel设置为当前CPU核数的2两倍

初始化代码如下:

Cache<String, Integer> lcache = CacheBuilder.newBuilder()
                  .maximumSize(100)
                  .concurrencyLevel(Runtime.getRuntime().availableProcessors()*2) // 当前CPU核数*2
.expireAfterWrite(30, TimeUnit.SECONDS) .build();

之后就可以通过put和getIfPresent来进行元素访问了,例如:

// 赋值
for
(int i=0; i<10000; i++) { lcache.put(String.valueOf(i), i); } // 查询 Integer value = lcache.getIfPresent("10");

 

posted on 2022-01-10 22:25  xinghebuluo  阅读(428)  评论(0编辑  收藏  举报

导航