码迷,mamicode.com
首页 > 系统相关 > 详细

Guava Cache的实现与源码分析

时间:2018-07-06 13:15:28      阅读:225      评论:0      收藏:0      [点我收藏+]

标签:调用   use   删除   image   creates   一个   数组   计算   队列   

一、概述

1、内存缓存

可看作一个jdk7的concurrentHashMap,核心功能get,put
但是比一般的map多了一些功能,如:
* ??过限失效(根据不同的维度失效,读后N秒,写后N秒,最大size,最大weight)
* 自动刷新
* 支持软引用和弱引用
* 监听删除

2、核心数据结构

和jdk7的HashMap相似
有N个Segment,每个Segment下是一个HashTable,每个HashTable里是一个链表
Guava的锁是一个比较重的操作,锁住的是整个Segment(Segment继承的是ReetrentLock,惊)

技术分享图片?

二、具体实现

0、一览众山小

主要的类:

CacheBuilder 设置参数,构建LoadingCache

LocalCache 是核心实现,虽然builder构建的是LocalLoadingCache(带refresh功能)和LocalManualCache(不带refresh功能),但其实那两个只是个壳子

1、CacheBuilder 构建器

提要:
记录所需参数

public final class CacheBuilder<K, V> {
    
    public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
        CacheLoader<? super K1, V1> loader) { // loader是用来自动刷新的
        checkWeightWithWeigher();
    return new LocalCache.LocalLoadingCache<>(this, loader);
    }
  
    public <K1 extends K, V1 extends V> Cache<K1, V1> build() { // 这个没有loader,就不会自动刷新
        checkWeightWithWeigher();
        checkNonLoadingCache();
        return new LocalCache.LocalManualCache<>(this);
    }
  
    int initialCapacity = UNSET_INT; // 初始map大小
    int concurrencyLevel = UNSET_INT; // 并发度
    long maximumSize = UNSET_INT;
    long maximumWeight = UNSET_INT;
    Weigher<? super K, ? super V> weigher;
    Strength keyStrength; // key强、弱、软引,默认为强
    Strength valueStrength; // value强、弱、软引,默认为强
    long expireAfterWriteNanos = UNSET_INT; // 写过期
    long expireAfterAccessNanos = UNSET_INT; //
    long refreshNanos = UNSET_INT; //
    Equivalence<Object> keyEquivalence; // 强引时为equals,否则为==
    Equivalence<Object> valueEquivalence; // 强引时为equals,否则为==
    RemovalListener<? super K, ? super V> removalListener; // 删除时的监听
    Ticker ticker; // 时间钟,用来获得当前时间的
    Supplier<? extends StatsCounter> statsCounterSupplier = NULL_STATS_COUNTER; // 计数器,用来记录get或者miss之类的数据
}

2、LocalCache

1)初始化

提要:
a)赋值
b)初始化Segment[]数组

 LocalCache(
      CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
    
    // a)把builder的参数赋值过来,略

    // b)构建Segment[]数组,原理可参照jdk7点concurrentHashMap
    int segmentShift = 0;
    int segmentCount = 1; // 设置为刚刚好比concurrencyLevel大的2的幂次方的值
    while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
      ++segmentShift;
      segmentCount <<= 1;
    }
    this.segmentShift = 32 - segmentShift;
    segmentMask = segmentCount - 1;

    this.segments = newSegmentArray(segmentCount);

    int segmentCapacity = initialCapacity / segmentCount; //每个Segment的容量
    int segmentSize = 1; // 刚刚好比容量大的2等幂次方的值
    while (segmentSize < segmentCapacity) {
      segmentSize <<= 1;
    }

    if (evictsBySize()) {
      // Ensure sum of segment max weights = overall max weights
      long maxSegmentWeight = maxWeight / segmentCount + 1;
      long remainder = maxWeight % segmentCount;
      for (int i = 0; i < this.segments.length; ++i) {
        if (i == remainder) {
          maxSegmentWeight--;
        }
        this.segments[i] =
            createSegment(segmentSize, maxSegmentWeight, builder.getStatsCounterSupplier().get());
      }
    } else {
      for (int i = 0; i < this.segments.length; ++i) {
        this.segments[i] =
            createSegment(segmentSize, UNSET_INT, builder.getStatsCounterSupplier().get()); // 往Segment数组里塞
      }
    }
  }
  
  
Segment(
   LocalCache<K, V> map,
   int initialCapacity,
   long maxSegmentWeight,
   StatsCounter statsCounter) {
 this.map = map;
 this.maxSegmentWeight = maxSegmentWeight;
 this.statsCounter = checkNotNull(statsCounter);
 initTable(newEntryArray(initialCapacity));
 // 当key是弱、软引用时,初始化keyReferenceQueue;其父类特性决定其gc时,会将被GC的元素放入该队列中
 keyReferenceQueue = map.usesKeyReferences() ? new ReferenceQueue<K>() : null;

 valueReferenceQueue = map.usesValueReferences() ? new ReferenceQueue<V>() : null;

 recencyQueue =
     map.usesAccessQueue()
         ? new ConcurrentLinkedQueue<ReferenceEntry<K, V>>()
         : LocalCache.<ReferenceEntry<K, V>>discardingQueue();

 writeQueue =
     map.usesWriteQueue()
         ? new WriteQueue<K, V>()
         : LocalCache.<ReferenceEntry<K, V>>discardingQueue();

 accessQueue =
     map.usesAccessQueue()
         ? new AccessQueue<K, V>()
         : LocalCache.<ReferenceEntry<K, V>>discardingQueue();
}

2)put

提要
a)找到key所在的segment,调用segment.put方法
b)锁住segment,清理
i)如果key存在
ii)如果key不存在
c)清理

class LocalCache {
    public V put(K key, V value) {
        checkNotNull(key);
        checkNotNull(value);
        int hash = hash(key); // 计算hash
        return segmentFor(hash).put(key, hash, value, false); // 找到hash所分配到的的Segment,put进去
    }
}

// 转而来看Segment的put方法
class Segment<K,V> implements ReentrantLock {
    V put(K key, int hash, V value, boolean onlyIfAbsent) {
      lock(); // 锁住一个segment
      try {
        long now = map.ticker.read(); //获得当前时间
        preWriteCleanup(now); //清除软/弱引用 详见 2.4

        int newCount = this.count + 1;
        if (newCount > this.threshold) { // 如有需要则扩容
          expand();
          newCount = this.count + 1;
        }

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

        // Look for an existing entry.
        // 根据不同情况决定是否要执行操作,1)count++ 更新数量 2)enqueueNotification 入队通知 3)setValue 更新值 4)evictEntries 淘汰缓存
        for (ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
          K entryKey = e.getKey();
          // 如果该key已经存在
          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) {
              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;
            }
          }
        }

        // 如果该key不存在,则新建一个entry.
        ++modCount;
        ReferenceEntry<K, V> newEntry = newEntry(key, hash, first);
        setValue(newEntry, key, value, now);
        table.set(index, newEntry);
        newCount = this.count + 1;
        this.count = newCount; // write-volatile
        evictEntries(newEntry);
        return null;
      } finally {
        unlock();
        postWriteCleanup();
      }
    }

    @GuardedBy("this")
    ReferenceEntry<K, V> newEntry(K key, int hash, @Nullable ReferenceEntry<K, V> next) {
      return map.entryFactory.newEntry(this, checkNotNull(key), hash, next);
    }
  }

利用map.entryFactory创建Entry。其中entryFactory的初始化是下述得到的

EntryFactory entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());

EntryFactory是个枚举类,枚举类还可以这么用,涨知识了!

enum EntryFactory {
    STRONG {
      @Override
      <K, V> ReferenceEntry<K, V> newEntry(
          Segment<K, V> segment, K key, int hash, @Nullable ReferenceEntry<K, V> next) {
        return new StrongEntry<>(key, hash, next);
      }
    },...,// 省略部分
    WEAK { // 软/弱引用的精髓!!!
      @Override
      <K, V> ReferenceEntry<K, V> newEntry(
          Segment<K, V> segment, K key, int hash, @Nullable ReferenceEntry<K, V> next) { // 所以!!!就是在这里!!!把这个queue放进去了,终于找到了
        return new WeakEntry<>(segment.keyReferenceQueue, key, hash, next);
      }
    }};

    // Masks used to compute indices in the following table.

    static final int ACCESS_MASK = 1;
    static final int WRITE_MASK = 2;
    static final int WEAK_MASK = 4;

    /** Look-up table for factories. */
    static final EntryFactory[] factories = {
      STRONG,
      STRONG_ACCESS,
      STRONG_WRITE,
      STRONG_ACCESS_WRITE,
      WEAK,
      WEAK_ACCESS,
      WEAK_WRITE,
      WEAK_ACCESS_WRITE,
    };

    static EntryFactory getFactory(
        Strength keyStrength, boolean usesAccessQueue, boolean usesWriteQueue) {
      int flags =
          ((keyStrength == Strength.WEAK) ? WEAK_MASK : 0)
              | (usesAccessQueue ? ACCESS_MASK : 0)
              | (usesWriteQueue ? WRITE_MASK : 0);
      return factories[flags];
    }

    // 抽象方法:创建一个entry
    abstract <K, V> ReferenceEntry<K, V> newEntry(
        Segment<K, V> segment, K key, int hash, @Nullable ReferenceEntry<K, V> next);
}
        
static class WeakEntry<K, V> extends WeakReference<K> implements ReferenceEntry<K, V> {
    WeakEntry(ReferenceQueue<K> queue, K key, int hash, @Nullable ReferenceEntry<K, V> next) {
      super(key, queue); // 抽丝剥茧,这个是Reference的方法,所以放到这个queue里面去,是Java WeakReference类自带的功能
      this.hash = hash;
      this.next = next;
    }
}

3)get

提要
a)找到key所在的segment,调用segment.get方法
b)得到ReferenceEntry,若存在,检查value是否过期,返回结果
c)清理

class LocalCache{
    public @Nullable V get(@Nullable Object key) {
        if (key == null) {
            return null;
        }
        int hash = hash(key);
        return segmentFor(hash).get(key, hash);
    }
}

class Segment{
    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); //如果发现没有找到或者过期了,则返回为null
          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);// 如果有loader且在刷新时间段中则刷新,否则跳过
          }
          tryDrainReferenceQueues(); // 这个幽灵一般的操作,难受
        }
        return null;
      } finally {
        postReadCleanup();
      }
    }
}

4)清理软/弱引用

每次put、get前后都会进行清理检查

    @GuardedBy("this")
    void preWriteCleanup(long now) { // 写前调用,其他方法类似,只是起了个不同的名字
      runLockedCleanup(now);
    }
    void runLockedCleanup(long now) { // 加锁+执行方法
      if (tryLock()) {
        try {
          drainReferenceQueues();
          expireEntries(now); // calls drainRecencyQueue
          readCount.set(0);
        } finally {
          unlock();
        }
      }
    }
    @GuardedBy("this")
    void drainReferenceQueues() { // 清空软/弱引用key和value
      if (map.usesKeyReferences()) {
        drainKeyReferenceQueue();
      }
      if (map.usesValueReferences()) {
        drainValueReferenceQueue();
      }
    }
    @GuardedBy("this")
    void drainKeyReferenceQueue() { // 清空软/弱引用key
      Reference<? extends K> ref;
      int i = 0;
      while ((ref = keyReferenceQueue.poll()) != null) {
        @SuppressWarnings("unchecked")
        ReferenceEntry<K, V> entry = (ReferenceEntry<K, V>) ref;
        map.reclaimKey(entry);
        if (++i == DRAIN_MAX) {
          break;
        }
      }
    }
}

// 之前一直没想明白的地方就是,这个keyReferenceQueue到底是什么时候被塞进去元素的???
// 需要看下创建entry的时候的操作!!!抽丝剥茧就能知道了


public class ReentrantLock implements Lock, java.io.Serializable {
    
    private Sync sync;
    
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        abstract void lock();

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread(); // 获取当前线程
            int c = getState();
            if (c == 0) { // 无线程持有,即无锁状态
                if (compareAndSetState(0, acquires)) { // 设置持有线程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { // 如果持有者就是当前线程,perfect
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }
}

Guava Cache的实现与源码分析

标签:调用   use   删除   image   creates   一个   数组   计算   队列   

原文地址:https://www.cnblogs.com/fairyfloss/p/Guava-Cache.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!