ehcache3-源码简析三

ehcache3的evict策略是怎样的呢？从put操作可以一窥，这里以单层heap cache为例。

ehcache3的evict策略不可设置，只能通过eviction-advisor建议evict，但这种建议得不到保证且低效。ehcache3的evict策略其实是一种基于样本的LRU算法，即在全量数据中采集一定数量样本（默认为8），在样本集中选取lastAccessTime最小的进行evict。

//put操作先存入元素，然后判断是否进行evict，有删减
public PutStatus put(final K key, final V value) throws StoreAccessException {

  checkKey(key);
  checkValue(value);
  final long now = timeSource.getTimeMillis();

    //map.compute会进入ConcurrentHashMap遍历元素并计算value
  map.compute(key, new BiFunction<K, OnHeapValueHolder<V>, OnHeapValueHolder<V>>() {
    @Override
    public OnHeapValueHolder<V> apply(K mappedKey, OnHeapValueHolder<V> mappedValue) {

      if (mappedValue != null && mappedValue.isExpired(now, TimeUnit.MILLISECONDS)) {
        updateUsageInBytesIfRequired(- mappedValue.size());
        mappedValue = null;
      }

      if (mappedValue == null) {
        OnHeapValueHolder<V> newValue = newCreateValueHolder(key, value, now, eventSink);
        if (newValue != null) {
          updateUsageInBytesIfRequired(newValue.size());
          statOutcome.set(StoreOperationOutcomes.PutOutcome.PUT);
        }
        return newValue;
      } else {
        OnHeapValueHolder<V> newValue = newUpdateValueHolder(key, mappedValue, value, now, eventSink);
        if (newValue != null) {
          updateUsageInBytesIfRequired(newValue.size() - mappedValue.size());
        } else {
          updateUsageInBytesIfRequired(- mappedValue.size());
        }
        statOutcome.set(StoreOperationOutcomes.PutOutcome.REPLACED);
        return newValue;
      }
    }
  });
  
    //enforceCapacity会判断是否进行evict操作。
  enforceCapacity();

}

ConcurrentHashMap的compute操作

public V compute(K key,
                 BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
  if (key == null || remappingFunction == null)
      throw new NullPointerException();
  int h = spread(key.hashCode());
  V val = null;
  int delta = 0;
  int binCount = 0;
  for (Node<K,V>[] tab = table;;) {
    Node<K,V> f; int n, i, fh;
    if (tab == null || (n = tab.length) == 0)
        tab = initTable();
    else if ((f = tabAt(tab, i = (n - 1) & h)) == null) {
      Node<K,V> r = new ReservationNode<K,V>();
      synchronized (r) {
        if (casTabAt(tab, i, null, r)) {
          binCount = 1;
          Node<K,V> node = null;
          try {
                //桶内无元素，计算key的value，如果value非null则添加该key-value（Node）；
                //如果value为null则什么也不做
            if ((val = remappingFunction.apply(key, null)) != null) {
                delta = 1;
                node = new Node<K,V>(h, key, val, null);
            }
          } finally {
            setTabAt(tab, i, node);
          }
        }
      }
      if (binCount != 0)
        break;
    }
    else if ((fh = f.hash) == MOVED)
      tab = helpTransfer(tab, f);
    else {
      synchronized (f) {
        if (tabAt(tab, i) == f) {
          if (fh >= 0) {
            binCount = 1;
            for (Node<K,V> e = f, pred = null;; ++binCount) {
              K ek;
              if (e.hash == h &&
                  ((ek = e.key) == key ||
                   (ek != null && key.equals(ek)))) {
                //桶内找到与key对应的node，计算value
                val = remappingFunction.apply(key, e.val);
                //如果value非null，则使用计算后的value替换旧的value
                if (val != null)
                  e.val = val;
                //如果value为null，则删除该node
                else {
                  delta = -1;
                  Node<K,V> en = e.next;
                  if (pred != null)
                    pred.next = en;
                  else
                    setTabAt(tab, i, en);
                }
                break;
              }
              pred = e;
              //桶内没有找到key对应的node，根据key计算value，
              //如果value非null则将该key-value加入桶内，如果value为null则什么都不做
              if ((e = e.next) == null) {
                val = remappingFunction.apply(key, null);
                if (val != null) {
                  delta = 1;
                  pred.next =
                      new Node<K,V>(h, key, val, null);
                }
                break;
              }
            }
          }
          else if (f instanceof TreeBin) {
            binCount = 1;
            TreeBin<K,V> t = (TreeBin<K,V>)f;
            TreeNode<K,V> r, p;
            if ((r = t.root) != null)
              p = r.findTreeNode(h, key, null);
            else
              p = null;
            V pv = (p == null) ? null : p.val;
            val = remappingFunction.apply(key, pv);
            if (val != null) {
              if (p != null)
                p.val = val;
              else {
                delta = 1;
                t.putTreeVal(h, key, val);
              }
            }
            else if (p != null) {
              delta = -1;
              if (t.removeTreeNode(p))
                setTabAt(tab, i, untreeify(t.first));
            }
          }
          }
      }
      if (binCount != 0) {
        if (binCount >= TREEIFY_THRESHOLD)
          treeifyBin(tab, i);
        break;
      }
    }
  }
  if (delta != 0)
    addCount((long)delta, binCount);
  return val;
}

protected void enforceCapacity() {
  StoreEventSink<K, V> eventSink = storeEventDispatcher.eventSink();
  try {
      //ATTEMPT_RATIO为4，即最多尝试evict4次，EVICTION_RATIO为2，即最多evict2个元素，capacity即我们设置的<heap unit="entries">x</heap>数，map.naturalSize()是当前已映射数
    for (int attempts = 0, evicted = 0; attempts < ATTEMPT_RATIO && evicted < EVICTION_RATIO
            && capacity < map.naturalSize(); attempts++) {
      //如果evict成功，evicted++
      if (evict(eventSink)) {
        evicted++;
      }
    }
    storeEventDispatcher.releaseEventSink(eventSink);
  } catch (RuntimeException re){
    storeEventDispatcher.releaseEventSinkAfterFailure(eventSink, re);
    throw re;
  }
}

boolean evict(final StoreEventSink<K, V> eventSink) {
  evictionObserver.begin();
  //产生的随机数用于确定首个样本的index
  final Random random = new Random();

    //第一轮采样。
    //SAMPLE_SIZE为8，表示最少采样8个样本（如果样本不足就8个，采完就行），
    //EVICTION_PRIORITIZER是一个Comparator，会比较node的lastAccessTime，
    //EVICTION_ADVISOR即evict建议，可以自定义，
    //第一轮采样会接收evict建议，如果第一轮年采样没evict的建议都是不evict，
    //则进行第二轮采样，第二轮采样会忽略evict建议。
    //注意，evictionAdvice在value存入时就已确定，即valueHolder中持有evictionAdvice（boolean）
  Map.Entry<K, OnHeapValueHolder<V>> candidate = map.getEvictionCandidate(random, SAMPLE_SIZE, EVICTION_PRIORITIZER, EVICTION_ADVISOR);

  if (candidate == null) {
      //第二轮采样
    // 2nd attempt without any advisor
    candidate = map.getEvictionCandidate(random, SAMPLE_SIZE, EVICTION_PRIORITIZER, noAdvice());
  }

  if (candidate == null) {
    return false;
  } else {
      //根据key删除元素
    final Map.Entry<K, OnHeapValueHolder<V>> evictionCandidate = candidate;
    final AtomicBoolean removed = new AtomicBoolean(false);
    map.computeIfPresent(evictionCandidate.getKey(), new BiFunction<K, OnHeapValueHolder<V>, OnHeapValueHolder<V>>() {
      @Override
      public OnHeapValueHolder<V> apply(K mappedKey, OnHeapValueHolder<V> mappedValue) {
        if (mappedValue.equals(evictionCandidate.getValue())) {
          removed.set(true);
          if (!(evictionCandidate.getValue() instanceof Fault)) {
            eventSink.evicted(evictionCandidate.getKey(), evictionCandidate.getValue());
            invalidationListener.onInvalidation(mappedKey, evictionCandidate.getValue());
          }
          updateUsageInBytesIfRequired(-mappedValue.size());
          return null;//return null会删除
        }
        return mappedValue;
      }
    });
    if (removed.get()) {
      evictionObserver.end(StoreOperationOutcomes.EvictionOutcome.SUCCESS);
      return true;
    } else {
      evictionObserver.end(StoreOperationOutcomes.EvictionOutcome.FAILURE);
      return false;
    }
  }
}

public Entry<K, V> getEvictionCandidate(Random rndm, int size, Comparator<? super V> prioritizer, EvictionAdvisor<? super K, ? super V> evictionAdvisor) {
  Node<K,V>[] tab = table;
  if (tab == null || size == 0) {
    return null;
  }

  K maxKey = null;
  V maxValue = null;

  int n = tab.length;
  int start = rndm.nextInt(n);

  Traverser<K, V> t = new Traverser<K, V>(tab, n, start, n);
  //advance()可以得到下一个node（下一个node有两种情况，1桶内，直接通过next得到，2桶内的next==null，则遍历下一个桶）
  for (Node<K, V> p; (p = t.advance()) != null;) {
    K key = p.key;
    V val = p.val;
    //adviseAgainstEviction即不建议evict
    if (!evictionAdvisor.adviseAgainstEviction(key, val)) {
        //通过prioritizer（Comparator）的比较，得到lastAccessTime最小的
      if (maxKey == null || prioritizer.compare(val, maxValue) > 0) {
        maxKey = key;
        maxValue = val;
      }
      //虽然已经样本数已经达到要求，但是仍然继续遍历当前桶内节点（t.index==terminalIndex）
      if (--size == 0) {
        for (int terminalIndex = t.index; (p = t.advance()) != null && t.index == terminalIndex; ) {
          key = p.key;
          val = p.val;
          if (!evictionAdvisor.adviseAgainstEviction(key, val) && prioritizer.compare(val, maxValue) > 0) {
            maxKey = key;
            maxValue = val;
          }
        }
        return new MapEntry<K, V>(maxKey, maxValue, this);
      }
    }
  }

  return getEvictionCandidateWrap(tab, start, size, maxKey, maxValue, prioritizer, evictionAdvisor);
}