import com.googlecode.concurrentlinkedhashmap.EntryWeigher; //导入依赖的package包/类
/**
 * Initialize a cache with initial capacity with weightedCapacity
 */
public static <K extends IMeasurableMemory, V extends IMeasurableMemory> ConcurrentLinkedHashCache<K, V> create(long weightedCapacity, EntryWeigher<K, V> entryWeiger)
{
    ConcurrentLinkedHashMap<K, V> map = new ConcurrentLinkedHashMap.Builder<K, V>()
                                        .weigher(entryWeiger)
                                        .maximumWeightedCapacity(weightedCapacity)
                                        .concurrencyLevel(DEFAULT_CONCURENCY_LEVEL)
                                        .build();

    return new ConcurrentLinkedHashCache<K, V>(map);
}
 

import com.googlecode.concurrentlinkedhashmap.EntryWeigher; //导入依赖的package包/类
/**
 * Initialize a cache with initial capacity with weightedCapacity
 */
public static <K extends IMeasurableMemory, V extends IMeasurableMemory> ConcurrentLinkedHashCache<K, V> create(long weightedCapacity, EntryWeigher<K, V> entryWeiger)
{
    ConcurrentLinkedHashMap<K, V> map = new ConcurrentLinkedHashMap.Builder<K, V>()
                                        .weigher(entryWeiger)
                                        .maximumWeightedCapacity(weightedCapacity)
                                        .concurrencyLevel(DEFAULT_CONCURENCY_LEVEL)
                                        .build();

    return new ConcurrentLinkedHashCache<>(map);
}
 

import com.googlecode.concurrentlinkedhashmap.EntryWeigher; //导入依赖的package包/类
/**
 * We can use Weighers.singleton() because Long can't be leaking memory
 * @return auto saving cache object
 */
private AutoSavingCache<KeyCacheKey, RowIndexEntry> initKeyCache()
{
    logger.info("Initializing key cache with capacity of {} MBs.", DatabaseDescriptor.getKeyCacheSizeInMB());

    long keyCacheInMemoryCapacity = DatabaseDescriptor.getKeyCacheSizeInMB() * 1024 * 1024;

    // as values are constant size we can use singleton weigher
    // where 48 = 40 bytes (average size of the key) + 8 bytes (size of value)
    ICache<KeyCacheKey, RowIndexEntry> kc;
    if (MemoryMeter.isInitialized())
    {
        kc = ConcurrentLinkedHashCache.create(keyCacheInMemoryCapacity);
    }
    else
    {
        logger.warn("MemoryMeter uninitialized (jamm not specified as java agent); KeyCache size in JVM Heap will not be calculated accurately. " +
                    "Usually this means cassandra-env.sh disabled jamm because you are using a buggy JRE; upgrade to the Sun JRE instead");
        /* We don't know the overhead size because memory meter is not enabled. */
        EntryWeigher<KeyCacheKey, RowIndexEntry> weigher = new EntryWeigher<KeyCacheKey, RowIndexEntry>()
        {
            public int weightOf(KeyCacheKey key, RowIndexEntry entry)
            {
                return key.key.length + entry.serializedSize();
            }
        };
        kc = ConcurrentLinkedHashCache.create(keyCacheInMemoryCapacity, weigher);
    }
    AutoSavingCache<KeyCacheKey, RowIndexEntry> keyCache = new AutoSavingCache<KeyCacheKey, RowIndexEntry>(kc, CacheType.KEY_CACHE, new KeyCacheSerializer());

    int keyCacheKeysToSave = DatabaseDescriptor.getKeyCacheKeysToSave();

    logger.info("Scheduling key cache save to each {} seconds (going to save {} keys).",
            DatabaseDescriptor.getKeyCacheSavePeriod(),
                keyCacheKeysToSave == Integer.MAX_VALUE ? "all" : keyCacheKeysToSave);

    keyCache.scheduleSaving(DatabaseDescriptor.getKeyCacheSavePeriod(), keyCacheKeysToSave);

    return keyCache;
}