ehcache3-源码简析二

ehcache对于offheap是如何管理的呢？从get操作可以一窥，这里以heap+offheap分层cache为例。

cache由heap+offheap组成时，authoritativeTier为OffHeapStore，OffHeapStore也会从map中get元素，该map就是EhcacheConcurrentOffHeapClockCache。EhcacheConcurrentOffHeapClockCache继承了AbstractConcurrentOffHeapMap，EhcacheConcurrentOffHeapClockCache也就具有了map的一些特性。AbstractConcurrentOffHeapMap中持有Segment数组，这点类似于jdk7中的ConcurrentHashMap，每一个Segment又是一个Map（但该Map有些特殊）。

public abstract class AbstractConcurrentOffHeapMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, ConcurrentMapInternals, HashingMap<K, V> {
    
    protected final Segment<K, V>[] segments;
    //可设置的最大segment数
    private static final int MAX_SEGMENTS = 65536;
    //与jdk7中的ConcurrentHashMap一样，也有并发度的概念，即多少个segment
    private static final int DEFAULT_CONCURRENCY = 16;
    
    //get元素时会调用该方法
    public MetadataTuple<V> computeIfPresentWithMetadata(K key, BiFunction<? super K, ? super MetadataTuple<V>, ? extends MetadataTuple<V>> remappingFunction) {
        //segmentFor会根据key的hash值找到对应的segment，在具体的segment上执行get操作（computeIfPresentWithMetadata），类似jdk7中的ConcurrentHashMap的逻辑
        return this.segmentFor(key).computeIfPresentWithMetadata(key, remappingFunction);
    }
}

EhcacheSegment继承了OffHeapHashMap，即EhcacheSegment也具有map的特征，但这个map不一般。

public class OffHeapHashMap<K, V> extends AbstractMap<K, V> implements MapInternals, Owner, HashingMap<K, V> {

    //......
    
    //EhcacheSegment中的hashtable为一个IntBuffer，这就是它的特别之处，这个IntBuffer是一块offheap内存（DirectByteBuffer）
    protected volatile IntBuffer hashtable;
    //hashtable的初始大小，128个entry
    private static final int INITIAL_TABLE_SIZE = 128;
    //resize大小，即负载因子
    private static final float TABLE_RESIZE_THRESHOLD = 0.5F;
    //entry大小，4个int
    protected static final int ENTRY_SIZE = 4;
    //entry第0个int
    protected static final int STATUS = 0;
    //entry第1个int，代表hashcode
    protected static final int KEY_HASHCODE = 1;
    //entry第2、3个int，代表key的offheap地址
    protected static final int ENCODING = 2;
    
    //......
    
    //EhcacheSegment的get操作
    public MetadataTuple<V> computeIfPresentWithMetadata(K key, BiFunction<? super K, ? super MetadataTuple<V>, ? extends MetadataTuple<V>> remappingFunction) {
      this.freePendingTables();
      int hash = key.hashCode();
      //hashtable是一个IntBuffer，该intBuffer中没4个int构成一个元素（entry），
      //entry中第一个int表示existingStatus，第二个int表示hash，后两个int组成的long表示key在offheap中的位置。
      //hashtable使用线性探测解决hash冲突，这里indexFor得到key在hashtable中未冲突的索引。
      int start = this.indexFor(spread(hash));
      //设置hashtable（intBuffer）的position，意在读取hashtable时，从start开始读，也即从key首次映射的索引开始读。
      this.hashtable.position(start);
      int limit = this.reprobeLimit();
      
        //开始线性探测
      for(int i = 0; i < limit; ++i) {
        if (!this.hashtable.hasRemaining()) {
          this.hashtable.rewind();
        }

        IntBuffer entry = (IntBuffer)this.hashtable.slice().limit(4);
        if (isTerminating(entry)) {
          return null;
        }
            //readLong(entry,2)就是从entry中读取一个地址（storageEngine可以根据该地址读取key、value），根据该地址再从storageEngine中获取key的真实值；
            //entry.get(1)是读取hash值。
        if (isPresent(entry) && this.keyEquals(key, hash, readLong((IntBuffer)entry, 2), entry.get(1))) {
          long existingEncoding = readLong((IntBuffer)entry, 2);
          int existingStatus = entry.get(0);
          //storageEngine.readValue会根据existingEncoding（即address）获取value，此时得到的existingValue是一个DirectByteBuffer
          MetadataTuple<V> existingValue = MetadataTuple.metadataTuple(this.storageEngine.readValue(existingEncoding), existingStatus & -4);
          //对DirectByteBuffer进行detach
          MetadataTuple<V> result = (MetadataTuple)remappingFunction.apply(key, existingValue);
          //.....
          return result;
        }
            //线性探测的下一个
        this.hashtable.position(this.hashtable.position() + 4);
      }
        
      return null;
    }
    
    //有相应的expand、shrink方法对hashtable进行动态调整
    //......
    
}

//detach
void detach() {
    if (mode == Mode.ATTACHED) {
      byte[] bytes = new byte[binaryValue.remaining()];
      binaryValue.get(bytes);
      binaryValue = ByteBuffer.wrap(bytes);
      mode = Mode.DETACHED;
    } else {
      throw new IllegalStateException("OffHeapValueHolder in mode " + mode + " cannot be prepared for delayed deserialization");
    }
}

//OffHeapBufferStorageEngine根据address读取value
public ByteBuffer readValueBuffer(long address) {
  int keyLength = this.storageArea.readInt(address + 4L);
  int valueLength = this.storageArea.readInt(address + 8L);
   //address, length
  return this.storageArea.readBuffer(address + 12L + (long)keyLength, valueLength).asReadOnlyBuffer();
}