org.cache2k.core

Class HeapCache<K,V>

java.lang.Object

org.cache2k.core.BaseCache<K,V>

org.cache2k.core.HeapCache<K,V>

All Implemented Interfaces:

Closeable, AutoCloseable, org.cache2k.AdvancedKeyValueSource<K,V>, org.cache2k.Cache<K,V>, CanCheckIntegrity, InternalCache<K,V>, org.cache2k.KeyValueSource<K,V>, org.cache2k.KeyValueStore<K,V>

Direct Known Subclasses:

IntHeapCache, LongHeapCache

public class HeapCache<K,V>
extends BaseCache<K,V>

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
static class	HeapCache.RunWithCatch
static class	HeapCache.Tunable

Field Summary

Fields

Modifier and Type	Field and Description
protected long	clearCnt Number of clear operations.
protected long	clearedTime
protected long	clearRemovedCnt Number of entries removed by clear.
protected InternalClock	clock
static org.cache2k.integration.ExceptionPropagator	DEFAULT_EXCEPTION_PROPAGATOR
protected org.cache2k.integration.ExceptionPropagator<K>	exceptionPropagator
protected Hash2<K,V>	hash
protected int	hashSeed
protected org.cache2k.core.CacheBaseInfo	info Statistics
protected long	internalExceptionCnt Number of internal exceptions.
protected long	keyMutationCnt Counts the number of key mutations.
protected org.cache2k.configuration.CacheType	keyType
protected org.cache2k.integration.AdvancedCacheLoader<K,V>	loader
protected Executor	loaderExecutor
Object	lock Structure lock of the cache.
CacheManagerImpl	manager
protected String	name
protected Executor	prefetchExecutor
protected long	startedTime
protected TimingHandler<K,V>	timing
static HeapCache.Tunable	TUNABLE
protected org.cache2k.configuration.CacheType	valueType

Constructor Summary

Constructors

Constructor and Description
HeapCache()

Method Summary

Modifier and Type	Method and Description
void	cancelTimerJobs() Preparation for shutdown.
Set<K>	checkAllPresent(Iterable<? extends K> keys)
void	checkClosed()
void	checkIntegrity() Check internal data structures and throw and exception if something is wrong, used for unit testing
void	clear()
void	clearLocalCache()
void	close()
void	closePart1()
void	closePart2(InternalCache _userCache)
V	computeIfAbsent(K key, Callable<V> callable) Code duplicates with Cache.get(Object)
boolean	containsAndRemove(K key)
boolean	containsKey(K key)
Map<K,V>	convertCacheEntry2ValueMap(Map<K,org.cache2k.CacheEntry<K,V>> _map)
Map<K,V>	convertValueMap(Map<K,ExaminationEntry<K,V>> _map)
protected <R> EntryAction<K,V,R>	createEntryAction(K key, Entry<K,V> e, Semantic<K,V,R> op)
Hash2<K,V>	createHashTable()
<T> T	executeWithGlobalLock(Job<T> job) Execute job while making sure that no other operations are going on.
void	expireAt(K key, long _millis)
protected void	expireEntry(Entry e)
void	expireOrScheduleFinalExpireEvent(Entry<K,V> e)
K	extractIntKeyObj(K key) The key object or null, for integer keyed caches
int	extractIntKeyValue(K key, int hc) Modified hash code or integer value for integer keyed caches
K	extractKeyObj(Entry<K,V> e)
int	extractModifiedHash(Entry e)
protected void	finishLoadOrEviction(Entry e, long _nextRefreshTime)
Set<K>	generateKeySet(Iterable<? extends K> _keys)
V	get(K key)
Map<K,V>	getAll(Iterable<? extends K> _inputKeys) JSR107 bulk interface.
org.cache2k.CacheManager	getCacheManager()
InternalClock	getClock() Time reference for the cache.
CommonMetrics	getCommonMetrics()
String	getCompleteName() Returns name of the cache with manager name.
org.cache2k.CacheEntry<K,V>	getEntry(K key)
protected Entry	getEntryInternal(K key)
protected Entry<K,V>	getEntryInternal(K key, int hc, int val)
String	getEntryState(K key)
InternalCacheInfo	getInfo() Generate cache statistics.
InternalCacheInfo	getInfo(InternalCache _userCache)
protected IntegrityState	getIntegrityState()
org.cache2k.configuration.CacheType	getKeyType()
InternalCacheInfo	getLatestInfo() Generate fresh statistics.
InternalCacheInfo	getLatestInfo(InternalCache _userCache)
long	getLocalSize()
Log	getLog() Normally a cache itself logs nothing, so just construct when needed.
String	getName()
Executor	getPrefetchExecutor()
int	getTotalEntryCount() This method is used for ConcurrentMapWrapper.size()
org.cache2k.configuration.CacheType	getValueType()
void	init()
protected void	initializeHeapCache()
void	initWithoutTimerHandler()
protected void	insert(Entry<K,V> e, V _value, long t0, long t, long _refreshTime, byte _updateStatistics, long _nextRefreshTime)
protected Entry<K,V>	insertNewEntry(K key, int hc, int val) Insert new entry in all structures (hash and eviction).
protected void	insertOrUpdateAndCalculateExpiry(Entry<K,V> e, V v, long t0, long t, long _refreshTime, byte _updateStatistics) Calculate the next refresh time if a timer / expiry is needed and call insert.
<R> R	invoke(K key, org.cache2k.processor.EntryProcessor<K,V,R> entryProcessor) Simply the EntryAction based code to provide the entry processor.
boolean	isClosed()
protected boolean	isKeepAfterExpired()
boolean	isNullValuePermitted()
protected boolean	isRecordRefreshTime()
protected boolean	isRefreshAhead()
protected boolean	isRejectNullValues()
protected boolean	isUpdateTimeNeeded() Don't update the entry last modification time and no expiry calculations are needed.
ConcurrentEntryIterator<K,V>	iterateAllHeapEntries() Returns all cache entries within the heap cache.
Iterator<org.cache2k.CacheEntry<K,V>>	iterator()
protected void	load(Entry<K,V> e)
void	loadAll(Iterable<? extends K> _keys, org.cache2k.CacheOperationCompletionListener l)
protected void	loadAndReplace(K key) Always fetch the value from the source.
void	logAndCountInternalException(String _text, Throwable _exception)
protected Entry<K,V>	lookupEntry(K key)
protected Entry<K,V>	lookupEntry(K key, int hc, int val)
protected Entry<K,V>	lookupEntryNoHitRecord(K key)
protected Entry<K,V>	lookupEntryNoHitRecord(K key, int hc, int val)
protected Entry<K,V>	lookupOrNewEntry(K key) Lookup or create a new entry.
protected Entry<K,V>	lookupOrNewEntry(K key, int hc, int val)
protected Entry<K,V>	lookupOrNewEntryNoHitRecord(K key)
int	modifiedHash(int h) This function calculates a modified hash code.
V	peek(K key)
Map<K,V>	peekAll(Iterable<? extends K> _inputKeys)
V	peekAndPut(K key, V _value)
V	peekAndRemove(K key)
V	peekAndReplace(K key, V _value)
org.cache2k.CacheEntry<K,V>	peekEntry(K key)
protected Entry<K,V>	peekEntryInternal(K key) Return the entry, if it is in the cache, without invoking the cache source.
protected Entry<K,V>	peekEntryInternal(K key, int hc, int val)
void	prefetch(K key)
void	prefetchAll(Iterable<? extends K> _keys, org.cache2k.CacheOperationCompletionListener l)
void	put(K key, V value)
void	putAll(Map<? extends K,? extends V> valueMap)
boolean	putIfAbsent(K key, V value)
protected void	putValue(Entry e, V _value) Update the value directly within entry lock.
protected void	recordHit(Entry e) Increment the hit counter, because entry was accessed.
void	reloadAll(Iterable<? extends K> _keys, org.cache2k.CacheOperationCompletionListener l)
void	remove(K key)
protected boolean	removeEntry(Entry e) Remove the entry from the hash and the replacement list.
void	removeEntryForEviction(Entry<K,V> e) Remove the entry from the hash table.
boolean	removeIfEquals(K key, V _value) Remove the object from the cache.
protected boolean	replace(K key, boolean _compare, V _oldValue, V _newValue) replace if value matches.
boolean	replace(K key, V _newValue)
boolean	replaceIfEquals(K key, V _oldValue, V _newValue)
org.cache2k.CacheEntry<K,V>	returnCacheEntry(ExaminationEntry<K,V> _entry)
org.cache2k.CacheEntry<K,V>	returnCacheEntry(K key, V _valueOrException)
protected org.cache2k.CacheEntry<K,V>	returnEntry(ExaminationEntry<K,V> e) Wrap entry in a separate object instance.
RuntimeException	returnNullValueDetectedException()
protected V	returnValue(Entry<K,V> e)
protected V	returnValue(V v)
void	setAdvancedLoader(org.cache2k.integration.AdvancedCacheLoader<K,V> al)
void	setCacheClosedListeners(Collection<org.cache2k.configuration.CustomizationSupplier<org.cache2k.event.CacheClosedListener>> l)
void	setCacheConfig(org.cache2k.configuration.Cache2kConfiguration c) called from CacheBuilder
void	setCacheManager(CacheManagerImpl cm)
void	setClock(InternalClock _clock)
void	setExceptionPropagator(org.cache2k.integration.ExceptionPropagator ep)
protected void	setFeatureBit(int _bitmask, boolean _flag)
void	setName(String n) Set the name and configure a logging, used within cache construction.
void	setTiming(TimingHandler<K,V> rh)
void	startRefreshProbationTimer(Entry<K,V> e, long _nextRefreshTime)
void	timerEventExpireEntry(Entry<K,V> e)
void	timerEventProbationTerminated(Entry<K,V> e)
void	timerEventRefresh(Entry<K,V> e)

Methods inherited from class org.cache2k.core.BaseCache

asMap, clearAndClose, closeCustomization, createCustomization, entries, execute, execute, execute, getStorage, invokeAll, keys, nameQualifier, removeAll, removeAll, requestInterface, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

TUNABLE

public static final HeapCache.Tunable TUNABLE

DEFAULT_EXCEPTION_PROPAGATOR

public static final org.cache2k.integration.ExceptionPropagator DEFAULT_EXCEPTION_PROPAGATOR

hashSeed

protected final int hashSeed

name

protected String name

manager

public CacheManagerImpl manager

loader

protected org.cache2k.integration.AdvancedCacheLoader<K,V> loader

clock

protected InternalClock clock

timing

protected TimingHandler<K,V> timing

lock

public 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.

info

protected org.cache2k.core.CacheBaseInfo info

Statistics

keyMutationCnt

protected volatile long keyMutationCnt

Counts the number of key mutations. The count is not guarded and racy, but does not need to be exact. We don't put it to the metrics, because we do not want to have this disabled.

clearedTime

protected long clearedTime

startedTime

protected long startedTime

clearRemovedCnt

protected long clearRemovedCnt

Number of entries removed by clear. Guarded by: lock

clearCnt

protected long clearCnt

Number of clear operations. Guarded by: lock

internalExceptionCnt

protected long internalExceptionCnt

Number of internal exceptions. Guarded by: lock.

See Also:

InternalCacheInfo.getInternalExceptionCount()

loaderExecutor

protected volatile Executor loaderExecutor

prefetchExecutor

protected volatile Executor prefetchExecutor

hash

protected final Hash2<K,V> hash

keyType

protected org.cache2k.configuration.CacheType keyType

valueType

protected org.cache2k.configuration.CacheType valueType

exceptionPropagator

protected org.cache2k.integration.ExceptionPropagator<K> exceptionPropagator

Constructor Detail

HeapCache

public HeapCache()

Method Detail

isKeepAfterExpired

protected final boolean isKeepAfterExpired()

isRejectNullValues

protected final boolean isRejectNullValues()

isNullValuePermitted

public final boolean isNullValuePermitted()

isRefreshAhead

protected final boolean isRefreshAhead()

isUpdateTimeNeeded

protected final boolean isUpdateTimeNeeded()

Don't update the entry last modification time and no expiry calculations are needed.

isRecordRefreshTime

protected final boolean isRecordRefreshTime()

setFeatureBit

protected final void setFeatureBit(int _bitmask,
                                   boolean _flag)

getCompleteName

public String getCompleteName()

Returns name of the cache with manager name.

See Also:

similar

getLog

public Log getLog()

Normally a cache itself logs nothing, so just construct when needed.

setCacheConfig

public void setCacheConfig(org.cache2k.configuration.Cache2kConfiguration c)

called from CacheBuilder

setTiming

public void setTiming(TimingHandler<K,V> rh)

setClock

public void setClock(InternalClock _clock)

setExceptionPropagator

public void setExceptionPropagator(org.cache2k.integration.ExceptionPropagator ep)

setAdvancedLoader

public void setAdvancedLoader(org.cache2k.integration.AdvancedCacheLoader<K,V> al)

setName

public void setName(String n)

Set the name and configure a logging, used within cache construction.

getName

public String getName()

setCacheManager

public void setCacheManager(CacheManagerImpl cm)

getKeyType

public org.cache2k.configuration.CacheType getKeyType()

getValueType

public org.cache2k.configuration.CacheType getValueType()

init

public void init()

initWithoutTimerHandler

public void initWithoutTimerHandler()

checkClosed

public void checkClosed()

clear

public final void clear()

clearLocalCache

public final void clearLocalCache()

initializeHeapCache

protected void initializeHeapCache()

cancelTimerJobs

public void cancelTimerJobs()

Preparation for shutdown. Cancel all pending timer jobs e.g. for expiry/refresh or flushing the storage.

isClosed

public boolean isClosed()

closePart1

public void closePart1()
                throws CacheClosedException

Throws:

CacheClosedException - if cache is closed or closing is initiated by another thread.

close

public void close()

closePart2

public void closePart2(InternalCache _userCache)

setCacheClosedListeners

public void setCacheClosedListeners(Collection<org.cache2k.configuration.CustomizationSupplier<org.cache2k.event.CacheClosedListener>> l)

iterator

public Iterator<org.cache2k.CacheEntry<K,V>> iterator()

Specified by:

iterator in class BaseCache<K,V>

recordHit

protected void recordHit(Entry e)

Increment the hit counter, because entry was accessed.

The hit counter is a dirty counter. In case of multiple CPU cores incrementing the same entry counter, increments will be lost. For the functionality of the eviction algorithm this is not a real loss, since still the most accessed entries will have more counts then the others. On 32 bit systems word tearing may occur. This will also have no real observable negative impact on the eviction, so we do not compensate for it.

The hit count is also used for access statistics. The dirty counting will effect the exact correctness of the access statistics.

Using a 64 bit counter per entry is basically a big waste of memory. When reducing to a 32 bit value is has approximately a negative performance impact of 30%.

get

public V get(K key)

returnEntry

protected org.cache2k.CacheEntry<K,V> returnEntry(ExaminationEntry<K,V> e)

Wrap entry in a separate object instance. We can return the entry directly, however we lock on the entry object.

getEntryState

public String getEntryState(K key)

returnCacheEntry

public org.cache2k.CacheEntry<K,V> returnCacheEntry(ExaminationEntry<K,V> _entry)

returnCacheEntry

public org.cache2k.CacheEntry<K,V> returnCacheEntry(K key,
                                                    V _valueOrException)

getEntry

public org.cache2k.CacheEntry<K,V> getEntry(K key)

getEntryInternal

protected Entry getEntryInternal(K key)

getEntryInternal

protected Entry<K,V> getEntryInternal(K key,
                                      int hc,
                                      int val)

finishLoadOrEviction

protected void finishLoadOrEviction(Entry e,
                                    long _nextRefreshTime)

removeEntry

protected boolean removeEntry(Entry 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.

peekAndPut

public V peekAndPut(K key,
                    V _value)

peekAndReplace

public V peekAndReplace(K key,
                        V _value)

putValue

protected final void putValue(Entry e,
                              V _value)

Update the value directly within entry lock. Since we did not start entry processing we do not need to notify any waiting threads.

replace

public boolean replace(K key,
                       V _newValue)

replaceIfEquals

public boolean replaceIfEquals(K key,
                               V _oldValue,
                               V _newValue)

replace

protected boolean replace(K key,
                          boolean _compare,
                          V _oldValue,
                          V _newValue)

replace if value matches. if value not matches, return the existing entry or the dummy entry.

peekEntryInternal

protected final Entry<K,V> 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.

peekEntryInternal

protected final Entry<K,V> peekEntryInternal(K key,
                                             int hc,
                                             int val)

containsKey

public boolean containsKey(K key)

peek

public V peek(K key)

peekEntry

public org.cache2k.CacheEntry<K,V> peekEntry(K key)

computeIfAbsent

public V computeIfAbsent(K key,
                         Callable<V> callable)

Code duplicates with Cache.get(Object)

putIfAbsent

public boolean putIfAbsent(K key,
                           V value)

put

public void put(K key,
                V value)

containsAndRemove

public boolean containsAndRemove(K key)

removeIfEquals

public boolean removeIfEquals(K key,
                              V _value)

Remove the object from the cache.

remove

public void remove(K key)

peekAndRemove

public V peekAndRemove(K key)

getPrefetchExecutor

public Executor getPrefetchExecutor()

prefetch

public void prefetch(K key)

prefetchAll

public void prefetchAll(Iterable<? extends K> _keys,
                        org.cache2k.CacheOperationCompletionListener l)

loadAll

public void loadAll(Iterable<? extends K> _keys,
                    org.cache2k.CacheOperationCompletionListener l)

reloadAll

public void reloadAll(Iterable<? extends K> _keys,
                      org.cache2k.CacheOperationCompletionListener l)

generateKeySet

public Set<K> generateKeySet(Iterable<? extends K> _keys)

checkAllPresent

public Set<K> checkAllPresent(Iterable<? extends K> keys)

loadAndReplace

protected void loadAndReplace(K key)

Always fetch the value from the source. That is a copy of getEntryInternal without freshness checks.

lookupOrNewEntry

protected Entry<K,V> lookupOrNewEntry(K key)

Lookup or create a new entry. The new entry is created, because we need it for locking within the data fetch.

lookupOrNewEntry

protected Entry<K,V> lookupOrNewEntry(K key,
                                      int hc,
                                      int val)

lookupOrNewEntryNoHitRecord

protected Entry<K,V> lookupOrNewEntryNoHitRecord(K key)

returnValue

protected V returnValue(V v)

returnValue

protected V returnValue(Entry<K,V> e)

lookupEntry

protected Entry<K,V> lookupEntry(K key)

lookupEntryNoHitRecord

protected Entry<K,V> lookupEntryNoHitRecord(K key)

lookupEntry

protected final Entry<K,V> lookupEntry(K key,
                                       int hc,
                                       int val)

lookupEntryNoHitRecord

protected final Entry<K,V> lookupEntryNoHitRecord(K key,
                                                  int hc,
                                                  int val)

insertNewEntry

protected Entry<K,V> insertNewEntry(K key,
                                    int hc,
                                    int val)

Insert new entry in all structures (hash and eviction). The insert at the eviction needs to be done under the same lock, to allow a check of the consistency.

removeEntryForEviction

public void removeEntryForEviction(Entry<K,V> e)

Remove the entry from the hash table. The entry is already removed from the replacement list. Stop the timer, if needed. The remove races with a clear. The clear is not updating each entry state to e.isGone() but just drops the whole hash table instead.

With completion of the method the entry content is no more visible. "Nulling" out the key or value of the entry is incorrect, since there can be another thread which is just about to return the entry contents.

load

protected void load(Entry<K,V> e)

insertOrUpdateAndCalculateExpiry

protected final void insertOrUpdateAndCalculateExpiry(Entry<K,V> e,
                                                      V v,
                                                      long t0,
                                                      long t,
                                                      long _refreshTime,
                                                      byte _updateStatistics)

Calculate the next refresh time if a timer / expiry is needed and call insert.

returnNullValueDetectedException

public RuntimeException returnNullValueDetectedException()

insert

protected final void insert(Entry<K,V> e,
                            V _value,
                            long t0,
                            long t,
                            long _refreshTime,
                            byte _updateStatistics,
                            long _nextRefreshTime)

timerEventRefresh

public void timerEventRefresh(Entry<K,V> e)

startRefreshProbationTimer

public void startRefreshProbationTimer(Entry<K,V> e,
                                       long _nextRefreshTime)

timerEventProbationTerminated

public void timerEventProbationTerminated(Entry<K,V> e)

logAndCountInternalException

public void logAndCountInternalException(String _text,
                                         Throwable _exception)

timerEventExpireEntry

public void timerEventExpireEntry(Entry<K,V> e)

expireOrScheduleFinalExpireEvent

public void expireOrScheduleFinalExpireEvent(Entry<K,V> e)

expireEntry

protected void expireEntry(Entry e)

iterateAllHeapEntries

public final ConcurrentEntryIterator<K,V> iterateAllHeapEntries()

Returns all cache entries within the heap cache. Entries that are expired or contain no valid data are not filtered out.

getAll

public Map<K,V> getAll(Iterable<? extends K> _inputKeys)

JSR107 bulk interface. The behaviour is compatible to the JSR107 TCK. We also need to be compatible to the exception handling policy, which says that the exception is to be thrown when most specific. So exceptions are only thrown, when the value which has produced an exception is requested from the map.

convertValueMap

public Map<K,V> convertValueMap(Map<K,ExaminationEntry<K,V>> _map)

convertCacheEntry2ValueMap

public Map<K,V> convertCacheEntry2ValueMap(Map<K,org.cache2k.CacheEntry<K,V>> _map)

peekAll

public Map<K,V> peekAll(Iterable<? extends K> _inputKeys)

putAll

public void putAll(Map<? extends K,? extends V> valueMap)

createEntryAction

protected <R> EntryAction<K,V,R> createEntryAction(K key,
                                                   Entry<K,V> e,
                                                   Semantic<K,V,R> op)

Specified by:

createEntryAction in class BaseCache<K,V>

invoke

public <R> R invoke(K key,
                    org.cache2k.processor.EntryProcessor<K,V,R> entryProcessor)

Simply the EntryAction based code to provide the entry processor. If we code it directly this might be a little bit more efficient, but it gives quite a code bloat which has lots of corner cases for loader and exception handling.

expireAt

public void expireAt(K key,
                     long _millis)

getLocalSize

public final long getLocalSize()

getTotalEntryCount

public final int getTotalEntryCount()

Description copied from interface: InternalCache

This method is used for ConcurrentMapWrapper.size()

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

getInfo

public final InternalCacheInfo getInfo()

Description copied from interface: InternalCache

Generate cache statistics. Some of the statistic values involve scanning portions of the cache content. To prevent system stress e.g. monitoring there is a the compute intensive parts will only be repeated if some time is passed.

getLatestInfo

public final InternalCacheInfo getLatestInfo()

Description copied from interface: InternalCache

Generate fresh statistics. This version is used by internal tests. This method is not intended to be called at high frequencies or for attaching monitoring or logging. Use the InternalCache.getInfo() method for requesting information for monitoring.

getInfo

public final InternalCacheInfo getInfo(InternalCache _userCache)

getLatestInfo

public final InternalCacheInfo getLatestInfo(InternalCache _userCache)

getCommonMetrics

public CommonMetrics getCommonMetrics()

executeWithGlobalLock

public <T> T executeWithGlobalLock(Job<T> job)

Execute job while making sure that no other operations are going on. In case the eviction is connected via a queue we need to stop the queue processing. On the other hand we needs to make sure that the queue is drained because this method is used to access the recent statistics or check integrity. Draining the queue is a two phase job: The draining may not do eviction since we hold the locks, after lifting the lock with do eviction and lock again. This ensures that all queued entries are processed up to the point when the method was called.

getClock

public final InternalClock getClock()

Description copied from interface: InternalCache

Time reference for the cache.

getCacheManager

public org.cache2k.CacheManager getCacheManager()

modifiedHash

public 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.

extractIntKeyValue

public int extractIntKeyValue(K key,
                              int hc)

Modified hash code or integer value for integer keyed caches

extractIntKeyObj

public K extractIntKeyObj(K key)

The key object or null, for integer keyed caches

extractModifiedHash

public int extractModifiedHash(Entry e)

extractKeyObj

public K extractKeyObj(Entry<K,V> e)

createHashTable

public Hash2<K,V> createHashTable()