|
Oracle® Coherence Java API Reference Release 12.1.2.0.3 E26043-02 |
|||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object
com.tangosol.net.cache.CachingMap
public class CachingMap
Map implementation that wraps two maps - a front map (assumed to be "inexpensive" and probably "incomplete") and a back map (assumed to be "complete" and "correct", but more "expensive") - using a read-through/write-through approach.
If the back map implements ObservableMap interface, the CachingMap provides four different strategies of invalidating the front map entries that have changed by other processes in the back map:
The front map implementation is assumed to be thread safe; additionally any modifications to the front map are allowed only after the corresponding lock is acquired against the ControlMap
.
Note: null values are not cached in the front map and therefore this implementation is not optimized for maps that allow null values to be stored.
Nested Class Summary | |
---|---|
protected class |
CachingMap.BackMapListener MapListener for back map responsible for keeping the front map coherent with the back map. |
protected class |
CachingMap.FrontMapListener MapListener for front map responsible for deregistering back map listeners upon front map eviction. |
Nested classes/interfaces inherited from interface java.util.Map |
---|
java.util.Map.Entry |
Field Summary | |
---|---|
static int |
LISTEN_ALL Invalidation strategy that instructs the CachingMap to listen to all back map events; this strategy is preferred when updates to the back map are frequent and with high probability come from the outside of this CachingMap; for example multiple CachingMap instances using the same back map with a large degree of key set overlap between front maps. |
static int |
LISTEN_AUTO Invalidation strategy that instructs the CachingMap implementation to switch automatically between LISTEN_PRESENT and LISTEN_ALL strategies based on the cache statistics. |
static int |
LISTEN_LOGICAL Invalidation strategy that instructs the CachingMap to listen to all back map events that are not synthetic. |
static int |
LISTEN_NONE No invalidation strategy. |
static int |
LISTEN_PRESENT Invalidation strategy that instructs the CachingMap to listen to the back map events related only to the items currently present in the front map; this strategy serves best when the changes to the back map come mostly from the CachingMap itself. |
protected int |
m_nStrategyCurrent The current invalidation strategy, which at times could be different from the target strategy. |
protected int |
m_nStrategyTarget The invalidation strategy that this map is to use. |
Constructor Summary | |
---|---|
CachingMap(java.util.Map mapFront, java.util.Map mapBack) Construct a CachingMap using two specified maps: FrontMap (aka "cache", "near" or "shallow") and BackMap (aka "actual", "real" or "deep"). |
|
CachingMap(java.util.Map mapFront, java.util.Map mapBack, int nStrategy) Construct a CachingMap using two specified maps: FrontMap (aka "cache", "near" or "shallow") and BackMap (aka "actual", "real" or "deep") and using the specified front map invalidation strategy. |
Method Summary | |
---|---|
void |
clear() Clears both the front and back maps. |
boolean |
containsKey(java.lang.Object oKey) Check whether or not this map contains a mapping for the specified key. |
boolean |
containsValue(java.lang.Object oValue) Check whether or not this CachingMap maps one or more keys to the specified value. |
protected int |
ensureInvalidationStrategy() Ensure that a strategy has been chosen and that any appropriate global listeners have been registered. |
java.util.Set |
entrySet() Obtain an set view of the mappings contained in this map. |
java.lang.Object |
get(java.lang.Object oKey) Obtain the value to which this map maps the specified key. |
java.util.Map |
getAll(java.util.Collection colKeys) Get all the specified keys, if they are in the cache. |
java.util.Map |
getBackMap() Obtain the back map reference. |
CacheStatistics |
getCacheStatistics() Obtain the CacheStatistics for this cache. |
ConcurrentMap |
getControlMap() Obtain the ConcurrentMap that should be used to synchronize the front map modification access. |
java.util.Map |
getFrontMap() Obtain the front map reference. |
long |
getInvalidationHits() Determine the rough number of front map invalidation hits since the cache statistics were last reset. |
long |
getInvalidationMisses() Determine the rough number of front map invalidation misses since the cache statistics were last reset. |
int |
getInvalidationStrategy() Obtain the invalidation strategy used by this CachingMap. |
long |
getTotalRegisterListener() Determine the total number of registerListener(Object oKey) operations since the cache statistics were last reset. |
protected MapListener |
instantiateBackMapListener() Factory pattern: instantiate back map listener. |
protected CachingMap.FrontMapListener |
instantiateFrontMapListener() Factory pattern: instantiate front map listener. |
protected void |
invalidateFront(java.lang.Object oKey) Invalidate the key from the front. |
protected boolean |
isCoherent() Determine if changes to the back map affect the front map so that data in the front map stays in sync. |
boolean |
isEmpty() Check whether or not this map is empty. |
java.util.Set |
keySet() Obtain an set view of the keys contained in this map. |
java.lang.Object |
put(java.lang.Object oKey, java.lang.Object oValue) Associates the specified value with the specified key in this map. |
java.lang.Object |
put(java.lang.Object oKey, java.lang.Object oValue, boolean fReturn, long cMillis) Implementation of put method that optionally skips the return value retrieval and allows to specify an expiry for the cache entry. |
void |
putAll(java.util.Map map) Copy all of the mappings from the specified map to this map. |
protected void |
registerFrontListener() Register the global front map listener. |
protected void |
registerListener() Register the global back map listener. |
protected void |
registerListener(java.lang.Object oKey) Register the back map listener for the specified key. |
void |
release() Release the CachingMap. |
java.lang.Object |
remove(java.lang.Object oKey) Remove the mapping for this key from this map if present. |
protected void |
resetInvalidationStrategy() Reset the "current invalidation strategy" flag. |
int |
size() Return the number of key-value mappings in this map. |
java.lang.String |
toString() For debugging purposes, format the contents of the CachingMap in a human readable format. |
protected void |
unregisterFrontListener() Unregister the global front map listener. |
protected void |
unregisterListener() Unregister the global back map listener. |
protected void |
unregisterListener(java.lang.Object oKey) Unregister the back map listener for the specified key. |
protected void |
validate(MapEvent evt) Validate the front map entry for the specified back map event. |
java.util.Collection |
values() Obtain an collection of the values contained in this map. |
Methods inherited from interface java.util.Map |
---|
equals, hashCode |
Field Detail |
---|
public static final int LISTEN_NONE
public static final int LISTEN_PRESENT
public static final int LISTEN_ALL
public static final int LISTEN_AUTO
public static final int LISTEN_LOGICAL
protected int m_nStrategyTarget
protected int m_nStrategyCurrent
Constructor Detail |
---|
public CachingMap(java.util.Map mapFront, java.util.Map mapBack)
LISTEN_AUTO
strategy.
mapBack
- back mapmapFront
- front mapSeppukuMapListener
public CachingMap(java.util.Map mapFront, java.util.Map mapBack, int nStrategy)
mapFront
- front mapmapBack
- back mapnStrategy
- specifies the strategy used for the front map invalidation; valid values are LISTEN_* constantsMethod Detail |
---|
public void release()
public java.util.Map getFrontMap()
Note: direct modifications of the returned map may cause an unpredictable behavior of the CachingMap.
public java.util.Map getBackMap()
Note: direct modifications of the returned map may cause an unpredictable behavior of the CachingMap.
public int getInvalidationStrategy()
public ConcurrentMap getControlMap()
protected boolean isCoherent()
public CacheStatistics getCacheStatistics()
public void clear()
clear
in interface java.util.Map
public boolean containsKey(java.lang.Object oKey)
containsKey
in interface java.util.Map
public boolean containsValue(java.lang.Object oValue)
containsValue
in interface java.util.Map
public java.util.Set entrySet()
entrySet
in interface java.util.Map
public java.lang.Object get(java.lang.Object oKey)
get
in interface java.util.Map
oKey
- the key objectpublic java.util.Map getAll(java.util.Collection colKeys)
Note: this implementation does not differentiate between missing keys or null values stored in the back map; in both cases the returned map will not contain the corresponding entry.
colKeys
- a collection of keys that may be in the named cachepublic boolean isEmpty()
isEmpty
in interface java.util.Map
public java.util.Set keySet()
keySet
in interface java.util.Map
public java.lang.Object put(java.lang.Object oKey, java.lang.Object oValue)
put
in interface java.util.Map
oKey
- key with which the specified value is to be associatedoValue
- value to be associated with the specified keypublic java.lang.Object put(java.lang.Object oKey, java.lang.Object oValue, boolean fReturn, long cMillis)
oKey
- the keyoValue
- the valuefReturn
- if true, the return value is required; otherwise the return value will be ignoredcMillis
- the number of milliseconds until the cache entry will expirejava.lang.UnsupportedOperationException
- if the requested expiry is a positive value and either the front map or the back map implementations do not support the expiration functionalityCacheMap.put(Object oKey, Object oValue, long cMillis)
public void putAll(java.util.Map map)
putAll
in interface java.util.Map
map
- Mappings to be stored in this mapprotected void invalidateFront(java.lang.Object oKey)
oKey
- the key to invalidateprotected void validate(MapEvent evt)
evt
- the MapEvent from the back mappublic java.lang.Object remove(java.lang.Object oKey)
remove
in interface java.util.Map
oKey
- key whose mapping is to be removed from the mappublic int size()
size
in interface java.util.Map
public java.util.Collection values()
values
in interface java.util.Map
public long getInvalidationHits()
An invalidation hit is an externally induced map event for an entry that exists in the front map.
public long getInvalidationMisses()
public long getTotalRegisterListener()
registerListener(Object oKey)
operations since the cache statistics were last reset.public java.lang.String toString()
protected void registerListener()
protected void unregisterListener()
protected void registerListener(java.lang.Object oKey)
oKey
- the keyprotected void unregisterListener(java.lang.Object oKey)
oKey
- the keyprotected void registerFrontListener()
protected void unregisterFrontListener()
protected int ensureInvalidationStrategy()
protected void resetInvalidationStrategy()
This method should be called only while the access to the front map is fully synchronised and the front map is empty to prevent stalled data.
protected MapListener instantiateBackMapListener()
protected CachingMap.FrontMapListener instantiateFrontMapListener()
|
Oracle® Coherence Java API Reference Release 12.1.2.0.3 E26043-02 |
|||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |