BaseCache (cache2k core package 0.21.1 API)

java.lang.Object
- org.cache2k.impl.BaseCache<E,K,T>

All Implemented Interfaces:

Closeable, AutoCloseable, Iterable<CacheEntry<K,T>>, Cache<K,T>, CacheSource<K,T>, CanCheckIntegrity, KeyValueSource<K,T>

Direct Known Subclasses:

ArcCache, LockFreeCache, LruCache
```
public abstract class BaseCache<E extends Entry,K,T>
extends Object
implements Cache<K,T>, CanCheckIntegrity, Iterable<CacheEntry<K,T>>
```
Foundation for all cache variants. All common functionality is in here. For a (in-memory) cache we need three things: a fast hash table implementation, an LRU list (a simple double linked list), and a fast timer. The variants implement different eviction strategies.
Locking: The cache has a single structure lock obtained via lock and also locks on each entry for operations on it. Though, mutation operations that happen on a single entry get serialized.

Author:

Jens Wilke; created: 2013-07-09

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`BaseCache.Info` Stable interface to request information from the cache, the object safes values that need a longer calculation time, other values are requested directly.
`protected class`	`BaseCache.MyTimerTask`
`static class`	`BaseCache.Tunable`

Field Summary

Fields
Modifier and Type	Field and Description
`protected BulkCacheSource<K,T>`	`bulkCacheSource`
`protected long`	`bulkGetCnt`
`protected long`	`clearedTime`
`protected EntryExpiryCalculator<K,T>`	`entryExpiryCalculator`
`protected int`	`evictedButInHashCnt` Needed to correct the counter invariants, because during eviction the entry might be removed from the replacement list, but still in the hash.
`protected long`	`evictedCnt`
`protected boolean`	`evictionNeeded` Flag during operation that indicates, that the cache is full and eviction needs to be done.
`protected ExceptionExpiryCalculator<K>`	`exceptionExpiryCalculator`
`protected long`	`exceptionMaxLinger`
`protected ExperimentalBulkCacheSource<K,T>`	`experimentalBulkCacheSource`
`protected long`	`expiredKeptCnt`
`protected long`	`expiredRemoveCnt`
`protected long`	`fetchButHitCnt`
`protected long`	`fetchCnt`
`protected long`	`fetchExceptionCnt`
`protected long`	`fetchMillis`
`protected int`	`hashSeed`
`protected BaseCache.Info`	`info`
`protected long`	`internalExceptionCnt` An exception that should not have happened and was not thrown to the application.
`protected long`	`keyMutationCount`
`protected Class`	`keyType`
`protected long`	`loadHitCnt` Entry was loaded from storage and fresh.
`protected long`	`loadMissCnt` Storage did not contain the requested entry.
`protected long`	`loadNonFreshAndFetchedCnt` Separate counter for loaded entries that needed a fetch.
`protected long`	`loadNonFreshCnt` Loaded from storage, but the entry was not fresh and cannot be returned.
`protected Object`	`lock` Structure lock of the cache.
`protected E[]`	`mainHash`
`protected Hash<E>`	`mainHashCtrl`
`protected CacheManagerImpl`	`manager`
`protected int`	`maximumBulkFetchSize`
`protected long`	`maxLinger` Time in milliseconds we keep an element
`protected int`	`maxSize` Maximum amount of elements in cache
`protected String`	`name`
`protected long`	`newEntryCnt`
`protected long`	`peekHitNotFreshCnt`
`protected long`	`peekMissCnt`
`protected long`	`putCnt`
`protected long`	`putNewEntryCnt`
`protected long`	`refreshCnt`
`protected E[]`	`refreshHash`
`protected Hash<E>`	`refreshHashCtrl`
`protected long`	`refreshHitCnt`
`protected CacheRefreshThreadPool`	`refreshPool`
`protected long`	`refreshSubmitFailedCnt`
`protected long`	`removedCnt`
`protected boolean`	`shutdownInitiated`
`protected Futures.WaitForAllFuture<?>`	`shutdownWaitFuture` Stuff that we need to wait for before shutdown may complete
`protected CacheSourceWithMetaInfo<K,T>`	`source`
`protected long`	`startedTime`
`protected StorageAdapter`	`storage`
`protected long`	`suppressedExceptionCnt`
`protected Timer`	`timer`
`protected int`	`timerCancelCount`
`protected TimerService`	`timerService`
`protected long`	`touchedTime`
`protected static BaseCache.Tunable`	`TUNABLE`
`protected Class`	`valueType`
`protected long`	`virginEvictCnt` A newly inserted entry was removed by the eviction without the fetch to complete.
`protected boolean`	`waitForClear` Stops creation of new entries when clear is ongoing.

Constructor Summary

Constructors
Constructor and Description

BaseCache()

Constructors
Constructor and Description
`BaseCache()`

Method Summary

Methods
Modifier and Type	Method and Description
`protected long`	`calcNextRefreshTime(K _key, T _newObject, long now, Entry _entry)`
`protected int`	`calculateHashEntryCount()`
`protected void`	`checkClosed()`
`protected static boolean`	`checkCyclicListIntegrity(Entry e)`
`protected E`	`checkForGhost(K key, int hc)` Check whether we have an entry in the ghost table remove it from ghost and insert it into the replacement list.
`void`	`checkIntegrity()` Check internal data structures and throw and exception if something is wrong, used for unit testing
`void`	`clear()`
`protected void`	`clearLocalCache()`
`void`	`clearTimingStatistics()`
`void`	`close()`
`protected boolean`	`conditionallyStartProcess(E e)`
`boolean`	`contains(K key)`
`void`	`destroy()`
`protected void`	`evictEventually()`
`protected void`	`expireEntry(E e)`
`protected long`	`fetch(E e)`
`protected long`	`fetchFromSource(E e)`
`protected long`	`fetchWithStorage(E e, boolean _needsFetch)`
`protected E`	`findEvictionCandidate()` Find an entry that should be evicted.
`void`	`flush()`
`T`	`get(K key)`
`Map<K,T>`	`getAll(K[] _keys)` JSR107 convenience getAll from array
`Map<K,T>`	`getAll(Set<? extends K> _keys)` JSR107 bulk interface
`void`	`getBulk(K[] _keys, T[] _result, BitSet _fetched, int s, int e)` Retrieve
`protected String`	`getCompleteName()` Returns name of the cache with manager name.
`protected static int`	`getCyclicListEntryCount(Entry e)`
`CacheEntry<K,T>`	`getEntry(K key)`
`protected E`	`getEntryInternal(K key)`
`long`	`getExpiredCnt()`
`protected String`	`getExtraStatistics()`
`long`	`getFetchesBecauseOfNewEntries()` For peek no fetch is counted if there is a storage miss, hence the extra counter.
`protected int`	`getFetchesInFlight()`
`abstract long`	`getHitCnt()`
`BaseCache.Info`	`getInfo()`
`protected IntegrityState`	`getIntegrityState()`
`BaseCache.Info`	`getLatestInfo()`
`protected static int`	`getListEntryCount(Entry _head)`
`protected int`	`getLocalSize()`
`protected Log`	`getLog()` Normally a cache itself logs nothing, so just construct when needed.
`String`	`getName()`
`StorageAdapter`	`getStorage()`
`int`	`getTotalEntryCount()`
`protected boolean`	`hasBackgroundRefreshAndServesExpiredValues()` Enabling background refresh means also serving expired values.
`protected boolean`	`hasKeepAfterExpired()`
`protected boolean`	`hasSharpTimeout()`
`protected boolean`	`hasSuppressExceptions()`
`void`	`init()` Registers the cache in a global set for the clearAllCaches function and registers it with the resource monitor.
`protected void`	`initializeHeapCache()`
`protected long`	`insert(E e, T v, long t0, long t, byte _updateStatistics)` Calculate the next refresh time if a timer / expiry is needed and call insert.
`protected long`	`insert(E e, T _value, long t0, long t, byte _updateStatistics, long _nextRefreshTime)`
`protected static <E extends Entry> E`	`insertAfterHeadCyclicList(E _head, E e)` Insert X into A B C, yields: A X B C.
`protected Entry`	`insertEntryFromStorage(StorageEntry se, boolean _needsFetch)` Insert the storage entry in the heap cache and return it.
`protected long`	`insertEntryFromStorage(StorageEntry se, E e, boolean _needsFetch)`
`protected long`	`insertFetched(E e, T v, long t0, long t)`
`protected static void`	`insertInList(Entry _head, Entry e)`
`protected static <E extends Entry> E`	`insertIntoHeadCyclicList(E _head, E e)` Insert element at the head of the list
`protected abstract void`	`insertIntoReplacementList(E e)` New cache entry, put it in the replacement algorithm structure
`protected static <E extends Entry> E`	`insertIntoTailCyclicList(E _head, E e)`
`protected long`	`insertOnPut(E e, T v, long t0, long t)`
`protected boolean`	`isClosed()`
`protected ClosableConcurrentHashEntryIterator<Entry>`	`iterateAllHeapEntries()` Returns all cache entries within the heap cache.
`protected ClosableIterator<Entry>`	`iterateLocalAndStorage()` Complete iteration of all entries in the cache, including storage / persisted entries.
`ClosableIterator<CacheEntry<K,T>>`	`iterator()`
`protected void`	`lockAndRunForPurge(Object key, PurgeableStorage.PurgeAction _action)` Insert a cache entry for the given key and run action under the entry lock.
`protected E`	`lookupEntry(K key, int hc)`
`protected E`	`lookupEntrySynchronized(K key)`
`protected E`	`lookupEntryUnsynchronized(K key, int hc)` Implement unsynchronized lookup if it is supported by the eviction.
`protected E`	`lookupOrNewEntrySynchronized(K key)` Lookup or create a new entry.
`protected int`	`modifiedHash(int h)` This function calculates a modified hash code.
`protected static <E extends Entry> void`	`moveToFront(E _head, E e)`
`protected abstract E`	`newEntry()` Entry object factory.
`protected E`	`newEntry(K key, int hc)` Insert new entry in all structures (hash and replacement list).
`T`	`peek(K key)`
`CacheEntry<K,T>`	`peekEntry(K key)`
`protected E`	`peekEntryInternal(K key)` Return the entry, if it is in the cache, without invoking the cache source.
`void`	`prefetch(K key)`
`void`	`prefetch(List<K> keys, int _startIndex, int _endIndexExclusive)`
`void`	`prefetch(Set<K> keys)`
`void`	`purge()`
`void`	`put(K key, T value)`
`boolean`	`putIfAbsent(K key, T value)`
`protected abstract void`	`recordHit(E e)` Record an entry hit.
`void`	`remove(K key)`
`void`	`removeAllAtOnce(Set<K> _keys)`
`protected boolean`	`removeEntry(E e)` Remove the entry from the hash and the replacement list.
`protected void`	`removeEntryFromReplacementList(E e)`
`protected static <E extends Entry> E`	`removeFromCyclicList(E _head, E e)`
`protected static Entry`	`removeFromCyclicList(Entry e)`
`protected static void`	`removeFromList(Entry e)`
`boolean`	`removeWithFlag(K key)` Remove the object mapped to a key from the cache.
`void`	`resetStorage(StorageAdapter _from, StorageAdapter to)` Change the storage implementation to another one or null for a disconnect
`protected CacheEntry<K,T>`	`returnEntry(Entry<E,K,T> e)` Wrap entry in a separate object instance.
`protected T`	`returnValue(Entry<E,K,T> e)`
`void`	`setBulkCacheSource(BulkCacheSource<K,T> s)`
`void`	`setCacheConfig(CacheConfig c)` called via reflection from CacheBuilder
`void`	`setCacheManager(CacheManagerImpl cm)`
`void`	`setEntryExpiryCalculator(EntryExpiryCalculator<K,T> v)`
`void`	`setExceptionExpiryCalculator(ExceptionExpiryCalculator<K> v)`
`void`	`setExperimentalBulkCacheSource(ExperimentalBulkCacheSource<K,T> g)`
`void`	`setExpirySeconds(int s)` Set the time in seconds after which the cache does an refresh of the element.
`protected void`	`setFeatureBit(int _bitmask, boolean _flag)`
`void`	`setName(String n)` Set the name and configure a logging, used within cache construction.
`void`	`setRefreshController(RefreshController<T> lc)` called via reflection from CacheBuilder
`void`	`setSource(CacheSource<K,T> g)`
`void`	`setSource(CacheSourceWithMetaInfo<K,T> eg)`
`protected long`	`stopStartTimer(long _nextRefreshTime, E e, long now)`
`protected void`	`timerEvent(E e, long _executionTime)` When the time has come remove the entry from the cache.
`String`	`toString()` Return status information.
`protected void`	`updateShutdownWaitFuture(Future<?> f)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - TUNABLE
```
protected static final BaseCache.Tunable TUNABLE
```
  - hashSeed
```
protected int hashSeed
```
  - maxSize
```
protected int maxSize
```
    Maximum amount of elements in cache
  - name
```
protected String name
```
  - manager
```
protected CacheManagerImpl manager
```
  - source
```
protected CacheSourceWithMetaInfo<K,T> source
```
  - maxLinger
```
protected long maxLinger
```
    Time in milliseconds we keep an element
  - exceptionMaxLinger
```
protected long exceptionMaxLinger
```
  - entryExpiryCalculator
```
protected EntryExpiryCalculator<K,T> entryExpiryCalculator
```
  - exceptionExpiryCalculator
```
protected ExceptionExpiryCalculator<K> exceptionExpiryCalculator
```
  - info
```
protected BaseCache.Info info
```
  - clearedTime
```
protected long clearedTime
```
  - startedTime
```
protected long startedTime
```
  - touchedTime
```
protected long touchedTime
```
  - timerCancelCount
```
protected int timerCancelCount
```
  - keyMutationCount
```
protected long keyMutationCount
```
  - putCnt
```
protected long putCnt
```
  - putNewEntryCnt
```
protected long putNewEntryCnt
```
  - removedCnt
```
protected long removedCnt
```
  - expiredKeptCnt
```
protected long expiredKeptCnt
```
  - expiredRemoveCnt
```
protected long expiredRemoveCnt
```
  - evictedCnt
```
protected long evictedCnt
```
  - refreshCnt
```
protected long refreshCnt
```
  - suppressedExceptionCnt
```
protected long suppressedExceptionCnt
```
  - fetchExceptionCnt
```
protected long fetchExceptionCnt
```
  - peekHitNotFreshCnt
```
protected long peekHitNotFreshCnt
```
  - peekMissCnt
```
protected long peekMissCnt
```
  - fetchCnt
```
protected long fetchCnt
```
  - fetchButHitCnt
```
protected long fetchButHitCnt
```
  - bulkGetCnt
```
protected long bulkGetCnt
```
  - fetchMillis
```
protected long fetchMillis
```
  - refreshHitCnt
```
protected long refreshHitCnt
```
  - newEntryCnt
```
protected long newEntryCnt
```
  - loadNonFreshCnt
```
protected long loadNonFreshCnt
```
    Loaded from storage, but the entry was not fresh and cannot be returned.
  - loadHitCnt
```
protected long loadHitCnt
```
    Entry was loaded from storage and fresh.
  - loadNonFreshAndFetchedCnt
```
protected long loadNonFreshAndFetchedCnt
```
    Separate counter for loaded entries that needed a fetch.
  - refreshSubmitFailedCnt
```
protected long refreshSubmitFailedCnt
```
  - internalExceptionCnt
```
protected long internalExceptionCnt
```
    An exception that should not have happened and was not thrown to the application. Only used for the refresh thread yet.
  - evictedButInHashCnt
```
protected int evictedButInHashCnt
```
    Needed to correct the counter invariants, because during eviction the entry might be removed from the replacement list, but still in the hash.
  - loadMissCnt
```
protected long loadMissCnt
```
    Storage did not contain the requested entry.
  - virginEvictCnt
```
protected long virginEvictCnt
```
    A newly inserted entry was removed by the eviction without the fetch to complete.
  - maximumBulkFetchSize
```
protected int maximumBulkFetchSize
```
  - lock
```
protected final Object lock
```
    Structure lock of the cache. Every operation that needs a consistent structure of the cache or modifies it needs to synchronize on this. Since this is a global lock, locking on it should be avoided and any operation under the lock should be quick.
  - refreshPool
```
protected CacheRefreshThreadPool refreshPool
```
  - mainHashCtrl
```
protected Hash<E extends Entry> mainHashCtrl
```
  - mainHash
```
protected E extends Entry[] mainHash
```
  - refreshHashCtrl
```
protected Hash<E extends Entry> refreshHashCtrl
```
  - refreshHash
```
protected E extends Entry[] refreshHash
```
  - experimentalBulkCacheSource
```
protected ExperimentalBulkCacheSource<K,T> experimentalBulkCacheSource
```
  - bulkCacheSource
```
protected BulkCacheSource<K,T> bulkCacheSource
```
  - timer
```
protected Timer timer
```
  - shutdownWaitFuture
```
protected Futures.WaitForAllFuture<?> shutdownWaitFuture
```
    Stuff that we need to wait for before shutdown may complete
  - shutdownInitiated
```
protected boolean shutdownInitiated
```
  - evictionNeeded
```
protected boolean evictionNeeded
```
    Flag during operation that indicates, that the cache is full and eviction needs to be done. Eviction is only allowed to happen after an entry is fetched, so at the end of an cache operation that increased the entry count we check whether something needs to be evicted.
  - keyType
```
protected Class keyType
```
  - valueType
```
protected Class valueType
```
  - storage
```
protected StorageAdapter storage
```
  - timerService
```
protected TimerService timerService
```
  - waitForClear
```
protected boolean waitForClear
```
    Stops creation of new entries when clear is ongoing.
- Constructor Detail
  - BaseCache
```
public BaseCache()
```
- Method Detail
  - hasSharpTimeout
```
protected final boolean hasSharpTimeout()
```
  - hasKeepAfterExpired
```
protected final boolean hasKeepAfterExpired()
```
  - hasSuppressExceptions
```
protected final boolean hasSuppressExceptions()
```
  - setFeatureBit
```
protected final void setFeatureBit(int _bitmask,
                 boolean _flag)
```
  - hasBackgroundRefreshAndServesExpiredValues
```
protected final boolean hasBackgroundRefreshAndServesExpiredValues()
```
    Enabling background refresh means also serving expired values.
  - getCompleteName
```
protected String getCompleteName()
```
    Returns name of the cache with manager name.
  - getLog
```
protected Log getLog()
```
    Normally a cache itself logs nothing, so just construct when needed.
  - resetStorage
```
public void resetStorage(StorageAdapter _from,
                StorageAdapter to)
```
    Change the storage implementation to another one or null for a disconnect
  - setCacheConfig
```
public void setCacheConfig(CacheConfig c)
```
    called via reflection from CacheBuilder
  - setEntryExpiryCalculator
```
public void setEntryExpiryCalculator(EntryExpiryCalculator<K,T> v)
```
  - setExceptionExpiryCalculator
```
public void setExceptionExpiryCalculator(ExceptionExpiryCalculator<K> v)
```
  - setRefreshController
```
public void setRefreshController(RefreshController<T> lc)
```
    called via reflection from CacheBuilder
  - setSource
```
public void setSource(CacheSourceWithMetaInfo<K,T> eg)
```
  - setSource
```
public void setSource(CacheSource<K,T> g)
```
  - setExperimentalBulkCacheSource
```
public void setExperimentalBulkCacheSource(ExperimentalBulkCacheSource<K,T> g)
```
  - setBulkCacheSource
```
public void setBulkCacheSource(BulkCacheSource<K,T> s)
```
  - setName
```
public void setName(String n)
```
    Set the name and configure a logging, used within cache construction.
  - setExpirySeconds
```
public void setExpirySeconds(int s)
```
    Set the time in seconds after which the cache does an refresh of the element. -1 means the element will be hold forever. 0 means the element will not be cached at all.
  - getName
```
public String getName()
```
    Specified by:
    
    getName in interface Cache<K,T>
  - setCacheManager
```
public void setCacheManager(CacheManagerImpl cm)
```
  - getStorage
```
public StorageAdapter getStorage()
```
  - init
```
public void init()
```
    Registers the cache in a global set for the clearAllCaches function and registers it with the resource monitor.
  - updateShutdownWaitFuture
```
protected void updateShutdownWaitFuture(Future<?> f)
```
  - checkClosed
```
protected void checkClosed()
```
  - clear
```
public final void clear()
```
    Specified by:
    
    clear in interface Cache<K,T>
  - clearLocalCache
```
protected final void clearLocalCache()
```
  - initializeHeapCache
```
protected void initializeHeapCache()
```
  - clearTimingStatistics
```
public void clearTimingStatistics()
```
  - purge
```
public void purge()
```
    Specified by:
    
    purge in interface Cache<K,T>
  - flush
```
public void flush()
```
    Specified by:
    
    flush in interface Cache<K,T>
  - isClosed
```
protected boolean isClosed()
```
  - destroy
```
public void destroy()
```
    Specified by:
    
    destroy in interface Cache<K,T>
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Cache<K,T>
  - iterateLocalAndStorage
```
protected ClosableIterator<Entry> iterateLocalAndStorage()
```
    Complete iteration of all entries in the cache, including storage / persisted entries. The iteration may include expired entries or entries with no valid data.
  - iterator
```
public ClosableIterator<CacheEntry<K,T>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<CacheEntry<K,T>>
    
    Specified by:
    
    iterator in interface Cache<K,T>
  - removeFromList
```
protected static void removeFromList(Entry e)
```
  - insertInList
```
protected static void insertInList(Entry _head,
                Entry e)
```
  - getListEntryCount
```
protected static final int getListEntryCount(Entry _head)
```
  - moveToFront
```
protected static final <E extends Entry> void moveToFront(E _head,
                                 E e)
```
  - insertIntoTailCyclicList
```
protected static final <E extends Entry> E insertIntoTailCyclicList(E _head,
                                           E e)
```
  - insertAfterHeadCyclicList
```
protected static final <E extends Entry> E insertAfterHeadCyclicList(E _head,
                                            E e)
```
    Insert X into A B C, yields: A X B C.
  - insertIntoHeadCyclicList
```
protected static final <E extends Entry> E insertIntoHeadCyclicList(E _head,
                                           E e)
```
    Insert element at the head of the list
  - removeFromCyclicList
```
protected static <E extends Entry> E removeFromCyclicList(E _head,
                                       E e)
```
  - removeFromCyclicList
```
protected static Entry removeFromCyclicList(Entry e)
```
  - getCyclicListEntryCount
```
protected static int getCyclicListEntryCount(Entry e)
```
  - checkCyclicListIntegrity
```
protected static boolean checkCyclicListIntegrity(Entry e)
```
  - recordHit
```
protected abstract void recordHit(E e)
```
    Record an entry hit.
  - insertIntoReplacementList
```
protected abstract void insertIntoReplacementList(E e)
```
    New cache entry, put it in the replacement algorithm structure
  - newEntry
```
protected abstract E newEntry()
```
    Entry object factory. Return an entry of the proper entry subtype for the replacement/eviction algorithm.
  - findEvictionCandidate
```
protected E findEvictionCandidate()
```
    Find an entry that should be evicted. Called within structure lock. After doing some checks the cache will call removeEntryFromReplacementList(Entry) if this entry will be really evicted. Pinned entries may be skipped. A good eviction algorithm returns another candidate on sequential calls, even if the candidate was not removed.
    Rationale: Within the structure lock we can check for an eviction candidate and may remove it from the list. However, we cannot process additional operations or events which affect the entry. For this, we need to acquire the lock on the entry first.
  - removeEntryFromReplacementList
```
protected void removeEntryFromReplacementList(E e)
```
  - checkForGhost
```
protected E checkForGhost(K key,
              int hc)
```
    Check whether we have an entry in the ghost table remove it from ghost and insert it into the replacement list. null if nothing there. This may also do an optional eviction if the size limit of the cache is reached, because some replacement algorithms (ARC) do this together.
  - lookupEntryUnsynchronized
```
protected E lookupEntryUnsynchronized(K key,
                          int hc)
```
    Implement unsynchronized lookup if it is supported by the eviction. If a null is returned the lookup is redone synchronized.
  - get
```
public T get(K key)
```
    Specified by:
    
    get in interface Cache<K,T>
    
    Specified by:
    
    get in interface CacheSource<K,T>
    
    Specified by:
    
    get in interface KeyValueSource<K,T>
  - returnEntry
```
protected CacheEntry<K,T> returnEntry(Entry<E,K,T> e)
```
    Wrap entry in a separate object instance. We can return the entry directly, however we lock on the entry object.
  - getEntry
```
public CacheEntry<K,T> getEntry(K key)
```
    Specified by:
    
    getEntry in interface Cache<K,T>
  - getEntryInternal
```
protected E getEntryInternal(K key)
```
  - insertEntryFromStorage
```
protected Entry insertEntryFromStorage(StorageEntry se,
                           boolean _needsFetch)
```
    Insert the storage entry in the heap cache and return it. Used when storage entries are queried. We need to check whether the entry is present meanwhile, get the entry lock and maybe fetch it from the source. Doubles with getEntryInternal(Object) except we do not need to retrieve the data from the storage again.
    
    Parameters:
    _needsFetch - if true the entry is fetched from CacheSource when expired.
    
    Returns:
    a cache entry is always returned, however, it may be outdated
  - lockAndRunForPurge
```
protected void lockAndRunForPurge(Object key,
                      PurgeableStorage.PurgeAction _action)
```
    Insert a cache entry for the given key and run action under the entry lock. If the cache entry has fresh data, we do not run the action. Called from storage. The entry referenced by the key is expired and will be purged.
  - evictEventually
```
protected final void evictEventually()
```
  - removeEntry
```
protected boolean removeEntry(E e)
```
    Remove the entry from the hash and the replacement list. There is a race condition to catch: The eviction may run in a parallel thread and may have already selected this entry.
  - peekEntryInternal
```
protected E peekEntryInternal(K key)
```
    Return the entry, if it is in the cache, without invoking the cache source.
    The cache storage is asked whether the entry is present. If the entry is not present, this result is cached in the local cache.
  - contains
```
public boolean contains(K key)
```
    Specified by:
    
    contains in interface Cache<K,T>
  - peek
```
public T peek(K key)
```
    Specified by:
    
    peek in interface Cache<K,T>
  - peekEntry
```
public CacheEntry<K,T> peekEntry(K key)
```
    Specified by:
    
    peekEntry in interface Cache<K,T>
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                  T value)
```
    Specified by:
    
    putIfAbsent in interface Cache<K,T>
  - put
```
public void put(K key,
       T value)
```
    Specified by:
    
    put in interface Cache<K,T>
  - removeWithFlag
```
public boolean removeWithFlag(K key)
```
    Remove the object mapped to a key from the cache.
    Operation with storage: If there is no entry within the cache there may be one in the storage, so we need to send the remove to the storage. However, if a remove() and a get() is going on in parallel it may happen that the entry gets removed from the storage and added again by the tail part of get(). To keep the cache and the storage consistent it must be ensured that this thread is the only one working on the entry.
  - remove
```
public void remove(K key)
```
    Specified by:
    
    remove in interface Cache<K,T>
  - prefetch
```
public void prefetch(K key)
```
    Specified by:
    
    prefetch in interface Cache<K,T>
  - prefetch
```
public void prefetch(List<K> keys,
            int _startIndex,
            int _endIndexExclusive)
```
    Specified by:
    
    prefetch in interface Cache<K,T>
  - prefetch
```
public void prefetch(Set<K> keys)
```
    Specified by:
    
    prefetch in interface Cache<K,T>
  - lookupOrNewEntrySynchronized
```
protected E lookupOrNewEntrySynchronized(K key)
```
    Lookup or create a new entry. The new entry is created, because we need it for locking within the data fetch.
  - returnValue
```
protected T returnValue(Entry<E,K,T> e)
```
  - lookupEntrySynchronized
```
protected E lookupEntrySynchronized(K key)
```
  - lookupEntry
```
protected E lookupEntry(K key,
            int hc)
```
  - newEntry
```
protected E newEntry(K key,
         int hc)
```
    Insert new entry in all structures (hash and replacement list). May evict an entry if the maximum capacity is reached.
  - calcNextRefreshTime
```
protected long calcNextRefreshTime(K _key,
                       T _newObject,
                       long now,
                       Entry _entry)
```
  - fetch
```
protected long fetch(E e)
```
  - conditionallyStartProcess
```
protected boolean conditionallyStartProcess(E e)
```
  - fetchWithStorage
```
protected long fetchWithStorage(E e,
                    boolean _needsFetch)
```
    Parameters:
    e -
    _needsFetch - true if value needs to be fetched from the cache source. This is false, when the we only need to peek for an value already mapped.
  - insertEntryFromStorage
```
protected long insertEntryFromStorage(StorageEntry se,
                          E e,
                          boolean _needsFetch)
```
  - fetchFromSource
```
protected long fetchFromSource(E e)
```
  - insertFetched
```
protected final long insertFetched(E e,
                 T v,
                 long t0,
                 long t)
```
  - insertOnPut
```
protected final long insertOnPut(E e,
               T v,
               long t0,
               long t)
```
  - insert
```
protected final long insert(E e,
          T v,
          long t0,
          long t,
          byte _updateStatistics)
```
    Calculate the next refresh time if a timer / expiry is needed and call insert.
  - insert
```
protected final long insert(E e,
          T _value,
          long t0,
          long t,
          byte _updateStatistics,
          long _nextRefreshTime)
```
    Parameters:
    _nextRefreshTime - -1/MAXVAL: eternal, 0: expires immediately
  - stopStartTimer
```
protected long stopStartTimer(long _nextRefreshTime,
                  E e,
                  long now)
```
  - timerEvent
```
protected void timerEvent(E e,
              long _executionTime)
```
    When the time has come remove the entry from the cache.
  - expireEntry
```
protected void expireEntry(E e)
```
  - iterateAllHeapEntries
```
protected final ClosableConcurrentHashEntryIterator<Entry> iterateAllHeapEntries()
```
    Returns all cache entries within the heap cache. Entries that are expired or contain no valid data are not filtered out.
  - removeAllAtOnce
```
public void removeAllAtOnce(Set<K> _keys)
```
    Specified by:
    
    removeAllAtOnce in interface Cache<K,T>
  - getAll
```
public Map<K,T> getAll(K[] _keys)
```
    JSR107 convenience getAll from array
  - getAll
```
public Map<K,T> getAll(Set<? extends K> _keys)
```
    JSR107 bulk interface
    
    Specified by:
    
    getAll in interface Cache<K,T>
  - getBulk
```
public void getBulk(K[] _keys,
           T[] _result,
           BitSet _fetched,
           int s,
           int e)
```
    Retrieve
  - getHitCnt
```
public abstract long getHitCnt()
```
  - calculateHashEntryCount
```
protected final int calculateHashEntryCount()
```
  - getLocalSize
```
protected final int getLocalSize()
```
  - getTotalEntryCount
```
public final int getTotalEntryCount()
```
    Specified by:
    
    getTotalEntryCount in interface Cache<K,T>
  - getExpiredCnt
```
public long getExpiredCnt()
```
  - getFetchesBecauseOfNewEntries
```
public long getFetchesBecauseOfNewEntries()
```
    For peek no fetch is counted if there is a storage miss, hence the extra counter.
  - getFetchesInFlight
```
protected int getFetchesInFlight()
```
  - getIntegrityState
```
protected IntegrityState getIntegrityState()
```
  - checkIntegrity
```
public final void checkIntegrity()
```
    Check internal data structures and throw and exception if something is wrong, used for unit testing
    
    Specified by:
    
    checkIntegrity in interface CanCheckIntegrity
  - getInfo
```
public final BaseCache.Info getInfo()
```
  - getLatestInfo
```
public final BaseCache.Info getLatestInfo()
```
  - getExtraStatistics
```
protected String getExtraStatistics()
```
  - toString
```
public String toString()
```
    Return status information. The status collection is time consuming, so this is an expensive operation.
    
    Specified by:
    
    toString in interface Cache<K,T>
    
    Overrides:
    
    toString in class Object
  - modifiedHash
```
protected final int modifiedHash(int h)
```
    This function calculates a modified hash code. The intention is to "rehash" the incoming integer hash codes to overcome weak hash code implementations. We expect good results for integers also. Also add a random seed to the hash to protect against attacks on hashes. This is actually a slightly reduced version of the java.util.HashMap hash modification.

Class BaseCache<E extends Entry,K,T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TUNABLE

hashSeed

maxSize

name

manager

source

maxLinger

exceptionMaxLinger

entryExpiryCalculator

exceptionExpiryCalculator

info

clearedTime

startedTime

touchedTime

timerCancelCount

keyMutationCount

putCnt

putNewEntryCnt

removedCnt

expiredKeptCnt

expiredRemoveCnt

evictedCnt

refreshCnt

suppressedExceptionCnt

fetchExceptionCnt

peekHitNotFreshCnt

peekMissCnt

fetchCnt

fetchButHitCnt

bulkGetCnt

fetchMillis

refreshHitCnt

newEntryCnt

loadNonFreshCnt

loadHitCnt

loadNonFreshAndFetchedCnt

refreshSubmitFailedCnt

internalExceptionCnt

evictedButInHashCnt

loadMissCnt

virginEvictCnt

maximumBulkFetchSize

lock

refreshPool

mainHashCtrl

mainHash

refreshHashCtrl

refreshHash

experimentalBulkCacheSource

bulkCacheSource

timer

shutdownWaitFuture

shutdownInitiated

evictionNeeded

keyType

valueType

storage

timerService

waitForClear

Constructor Detail

BaseCache

Method Detail

hasSharpTimeout

hasKeepAfterExpired

hasSuppressExceptions

setFeatureBit

hasBackgroundRefreshAndServesExpiredValues

getCompleteName

getLog

resetStorage

setCacheConfig

setEntryExpiryCalculator

setExceptionExpiryCalculator