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();
}