public class LocalCache extends OldCache implements CacheMap
Modifier and Type | Class and Description |
---|---|
class |
LocalCache.Entry
A holder for a cached value.
|
protected class |
LocalCache.InternalListener
An internal MapListener that listens to this cache and reports changes to the CacheStore.
|
protected class |
LocalCache.KeyMask
A class that masks certain changes so that they are not reported back to the CacheStore.
|
OldCache.EntrySet, OldCache.EvictionPolicy, OldCache.InternalEvictionPolicy, OldCache.InternalUnitCalculator, OldCache.KeySet, OldCache.UnitCalculator, OldCache.ValuesCollection
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
ConfigurableCacheMap.EvictionApprover
Modifier and Type | Field and Description |
---|---|
static int |
DEFAULT_EXPIRE
By default, the cache entries never expire.
|
protected LocalCache.KeyMask |
DEFAULT_KEY_MASK
The default key mask that ignores nothing.
|
static int |
DEFAULT_UNITS
By default, the cache size (in units) is infinite.
|
DEFAULT_FLUSH, DEFAULT_PRUNE, EVICTION_POLICY_EXTERNAL, EVICTION_POLICY_HYBRID, EVICTION_POLICY_LFU, EVICTION_POLICY_LRU, INSTANCE_BINARY, INSTANCE_FIXED, INSTANCE_HYBRID, INSTANCE_LFU, INSTANCE_LRU, m_apprvrEvict, m_arrayExpiry, m_calculator, m_cAvgTouch, m_cCurUnits, m_cExpiryDelay, m_cMaxUnits, m_cPruneUnits, m_dflPruneLevel, m_fIncrementalEvict, m_iterEvict, m_listenerSupport, m_lLastPrune, m_lNextFlush, m_nCalculatorType, m_nEvictionType, m_nUnitFactor, m_policy, m_stats, UNIT_CALCULATOR_BINARY, UNIT_CALCULATOR_EXTERNAL, UNIT_CALCULATOR_FIXED
BIGGEST_MODULO, DEFAULT_GROWTHRATE, DEFAULT_INITIALSIZE, DEFAULT_LOADFACTOR, m_aeBucket, m_cCapacity, m_cEntries, m_colValues, m_flGrowthRate, m_flLoadFactor, m_oIterActive, m_setEntries, m_setKeys, PRIME_MODULO, RESIZING
EXPIRY_DEFAULT, EXPIRY_NEVER
Constructor and Description |
---|
LocalCache()
Construct the cache manager.
|
LocalCache(int cUnits)
Construct the cache manager.
|
LocalCache(int cUnits, int cExpiryMillis)
Construct the cache manager.
|
LocalCache(int cUnits, int cExpiryMillis, CacheLoader loader)
Construct the cache manager.
|
Modifier and Type | Method and Description |
---|---|
void |
clear()
Removes all mappings from this map.
|
Object |
get(Object oKey)
If the specified item is in the cache, return it.
|
Map |
getAll(Collection colKeys)
Get all the specified keys, if they are in the cache.
|
CacheLoader |
getCacheLoader()
Determine the loader used by this LocalCache, if any.
|
protected CacheStore |
getCacheStore()
Determine the store used by this LocalCache, if any.
|
SafeHashMap.Entry |
getEntry(Object oKey)
Locate an Entry in the hash map based on its key.
|
protected LocalCache.KeyMask |
getKeyMask()
ThreadLocal: Get the current key mask for the current thread.
|
protected SafeHashMap.Entry |
instantiateEntry()
Factory method.
|
protected MapListener |
instantiateInternalListener()
Factory pattern: Instantiate an internal MapListener to listen to this cache and report changes to the CacheStore.
|
protected MapEvent |
instantiateMapEvent(int nId, Object oKey, Object oValueOld, Object oValueNew)
Factory pattern: instantiate a new CacheEvent corresponding to the specified parameters.
|
void |
load(Object oKey)
Indicates to the cache that the specified key should be loaded into the cache, if it is not already in the cache.
|
void |
loadAll()
Indicates to the cache that it should load data from its loader to fill the cache; this is sometimes referred to as "pre-loading" or "warming" a cache.
|
void |
loadAll(Collection colKeys)
Indicates to the cache that the specified keys should be loaded into the cache, if they are not already in the cache.
|
Object |
peek(Object oKey)
Checks for a valid entry corresponding to the specified key in the cache, and returns the corresponding value if it is.
|
Map |
peekAll(Collection colKeys)
Checks for a valid entry corresponding to each specified key in the cache, and places the corresponding value in the returned map if it is.
|
Object |
remove(Object oKey)
Removes the mapping for this key from this map if present.
|
protected boolean |
removeEvicted(OldCache.Entry entry)
Remove an entry (if it is eligible for eviction) because it has expired.
|
void |
setCacheLoader(CacheLoader loader)
Specify the loader used by this LocalCache.
|
protected void |
setKeyMask(LocalCache.KeyMask mask)
ThreadLocal: Set the key mask for the current thread.
|
addMapListener, addMapListener, addMapListener, adjustUnits, checkFlush, checkSize, configureEviction, configureUnitCalculator, containsKey, dispatchEvent, evict, evict, evictAll, getCacheEntry, getCacheHits, getCacheMisses, getCacheStatistics, getEntryInternal, getEvictionApprover, getEvictionPolicy, getEvictionType, getExpiryDelay, getFlushTime, getHighUnits, getHitProbability, getLowUnits, getMapListenerSupport, getNextExpiryTime, getUnitCalculator, getUnitCalculatorType, getUnitFactor, getUnits, hasListeners, instantiateEntrySet, instantiateKeySet, instantiateValuesCollection, isEmpty, isIncrementalEviction, prune, put, put, removeExpired, removeIfExpired, removeMapListener, removeMapListener, removeMapListener, resetHitStatistics, setEvictionApprover, setEvictionPolicy, setEvictionType, setExpiryDelay, setFlushTime, setHighUnits, setIncrementalEviction, setLowUnits, setUnitCalculator, setUnitCalculatorType, setUnitFactor, size, toExternalUnits, toInternalUnits, toString
clone, cloneEntryList, entrySet, getBucketIndex, getStableBucketArray, grow, instantiateEntry, isActiveIterator, iteratorActivated, iteratorDeactivated, keySet, removeEntryInternal, values
containsValue, equals, hashCode, putAll
finalize, getClass, notify, notifyAll, wait, wait, wait
addMapListener, addMapListener, addMapListener, removeMapListener, removeMapListener, removeMapListener
compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, getOrDefault, hashCode, isEmpty, keySet, merge, putAll, putIfAbsent, remove, replace, replace, replaceAll, size, values
public static final int DEFAULT_UNITS
public static final int DEFAULT_EXPIRE
protected final LocalCache.KeyMask DEFAULT_KEY_MASK
public LocalCache()
public LocalCache(int cUnits)
cUnits
- the number of units that the cache manager will cache before pruning the cachepublic LocalCache(int cUnits, int cExpiryMillis)
cUnits
- the number of units that the cache manager will cache before pruning the cachecExpiryMillis
- the number of milliseconds that each cache entry lives before being automatically expiredpublic LocalCache(int cUnits, int cExpiryMillis, CacheLoader loader)
cUnits
- the number of units that the cache manager will cache before pruning the cachecExpiryMillis
- the number of milliseconds that each cache entry lives before being automatically expiredloader
- the CacheLoader or CacheStore to usepublic void clear()
public Object remove(Object oKey)
remove
in interface Map
remove
in class OldCache
oKey
- key whose mapping is to be removed from the mappublic CacheLoader getCacheLoader()
public void setCacheLoader(CacheLoader loader)
loader
- loader to use, or nullpublic Object get(Object oKey)
public SafeHashMap.Entry getEntry(Object oKey)
public Map getAll(Collection colKeys)
The result of this method is defined to be semantically the same as the following implementation, without regards to threading issues:
Map map = new AnyMap(); // could be hash map or ... for (Iterator iter = col.iterator(); iter.hasNext(); ) { Object oKey = iter.next(); Object oVal = get(oKey); if (oVal != null || containsKey(oKey)) { map.put(oKey, oVal); } } return map;
public void load(Object oKey)
If a valid entry with the specified key already exists in the cache, or if the cache does not have a loader, then this method has no effect.
An implementation may perform the load operation asynchronously.
oKey
- the key to request to be loadedpublic void loadAll()
The specific set of data that will be loaded is unspecified. The implementation may choose to load all data, some specific subset of the data, or no data. An implementation may require that the loader implement the IterableCacheLoader interface in order for this method to load any data.
An implementation may perform the load operation asynchronously.
public void loadAll(Collection colKeys)
The result of this method is defined to be semantically the same as the following implementation:
CacheLoader loader = getCacheLoader(); if (loader != null && !colKeys.isEmpty()) { Set setRequest = new HashSet(colKeys); setRequest.removeAll(peekAll(colKeys).keySet()); if (!setRequest.isEmpty()) { Map map = loader.loadAll(colKeys); if (!map.isEmpty()) { putAll(map); } } }
colKeys
- a collection of keys to request to be loadedpublic Object peek(Object oKey)
oKey
- the key to "peek" into the cache forpublic Map peekAll(Collection colKeys)
The result of this method is defined to be semantically the same as the following implementation, without regards to threading issues:
Map map = new HashMap(); for (Iterator iter = colKeys.iterator(); iter.hasNext(); ) { Object oKey = iter.next(); Object oValue = peek(oKey); if (oValue != null || containsKey(oKey)) { map.put(oKey, oValue); } } return map;
colKeys
- a collection of keys to "peek" into the cache forprotected CacheStore getCacheStore()
protected LocalCache.KeyMask getKeyMask()
protected void setKeyMask(LocalCache.KeyMask mask)
mask
- the new key mask, or null to clear the maskprotected boolean removeEvicted(OldCache.Entry entry)
removeEvicted
in class OldCache
entry
- the expired cache entryprotected MapEvent instantiateMapEvent(int nId, Object oKey, Object oValueOld, Object oValueNew)
instantiateMapEvent
in class OldCache
protected MapListener instantiateInternalListener()
protected SafeHashMap.Entry instantiateEntry()
instantiateEntry
in class OldCache