|
Oracle® Coherence Java API Reference Release 3.7.1.0 E22843-01 |
|||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object
com.tangosol.util.Base
com.tangosol.util.SegmentedHashMap
com.tangosol.util.SegmentedConcurrentMap
public class SegmentedConcurrentMap
An implementation of SegmentedHashMap that also implements the ConcurrentMap interface.
See ConcurrentMap
Nested Class Summary | |
---|---|
protected class |
SegmentedConcurrentMap.ConditionalRemoveAction Action support for a conditional remove(). |
static interface |
SegmentedConcurrentMap.ContentionObserver ContentionObserver is used to observe the contention lock-related actions performed on the concurrent map. |
class |
SegmentedConcurrentMap.LockableEntry LockableEntry is an Entry that supports locking. |
protected class |
SegmentedConcurrentMap.LockAction Action support for lock(). |
protected class |
SegmentedConcurrentMap.RemoveAction Action support for remove(). |
protected static class |
SegmentedConcurrentMap.SizeAction Action support for size(). |
protected class |
SegmentedConcurrentMap.UnlockAction Action support for unlock(). |
Nested classes/interfaces inherited from class com.tangosol.util.SegmentedHashMap |
---|
SegmentedHashMap.ContainsValueAction, SegmentedHashMap.Entry, SegmentedHashMap.EntryAction, SegmentedHashMap.EntryActionAdapter, SegmentedHashMap.EntrySet, SegmentedHashMap.GetEntryAction, SegmentedHashMap.InsertAction, SegmentedHashMap.IterableEntryAction, SegmentedHashMap.KeySet, SegmentedHashMap.Segment, SegmentedHashMap.ValuesCollection |
Nested classes/interfaces inherited from interface java.util.Map |
---|
java.util.Map.Entry |
Field Summary | |
---|---|
protected SegmentedConcurrentMap.ConditionalRemoveAction |
m_actionConditionalRemove The singleton action for conditional remove. |
protected SegmentedConcurrentMap.LockAction |
m_actionLock The action for lock() support. |
protected SegmentedConcurrentMap.SizeAction |
m_actionSize The singleton action for size support. |
protected SegmentedConcurrentMap.UnlockAction |
m_actionUnlock The action for unlock() support. |
protected static java.util.concurrent.atomic.AtomicReferenceFieldUpdater |
m_atomicUpdaterValue AtomicUpdater for the entry value. |
protected SegmentedConcurrentMap.ContentionObserver |
m_contentionObserver The ContentionObserver; may be null. |
protected Gate |
m_gateLockAll The Gate controlling LOCK_ALL access for this map. |
Fields inherited from interface com.tangosol.util.ConcurrentMap |
---|
LOCK_ALL |
Constructor Summary | |
---|---|
SegmentedConcurrentMap() Default constructor. |
|
SegmentedConcurrentMap(int cInitialBuckets, float flLoadFactor, float flGrowthRate) Construct a SegmentedConcurrentMap using the specified settings. |
|
SegmentedConcurrentMap(int cInitialBuckets, float flLoadFactor, float flGrowthRate, SegmentedConcurrentMap.ContentionObserver contentionObserver) Construct a thread-safe hash map using the specified settings. |
|
SegmentedConcurrentMap(SegmentedConcurrentMap.ContentionObserver contentionObserver) Construct a SegmentedConcurrentMap with the default settings and the specified ContentionObserver |
Method Summary | |
---|---|
void |
clear() Removes all mappings from this map. |
protected SegmentedConcurrentMap.ConditionalRemoveAction |
getConditionalRemoveAction() Return the registered action for conditional remove. |
SegmentedConcurrentMap.ContentionObserver |
getContentionObserver() Return the ContentionObserver for this SegmentedConcurrentMap. |
protected SegmentedConcurrentMap.LockAction |
getLockAction() Return the registered action for lock(). |
protected SegmentedConcurrentMap.SizeAction |
getSizeAction() Return the registered action for size(). |
protected SegmentedConcurrentMap.UnlockAction |
getUnlockAction() Return the registered action for unlock(). |
protected void |
initializeActions() Initialize the EntryAction's for this map. |
protected SegmentedConcurrentMap.ConditionalRemoveAction |
instantiateConditionalRemoveAction() Factory for ConditionalRemoveAction |
protected SegmentedHashMap.Entry |
instantiateEntry(java.lang.Object oKey, java.lang.Object oValue, int nHash) Factory for Entry. |
protected SegmentedConcurrentMap.LockAction |
instantiateLockAction() Factory for LockAction |
protected SegmentedHashMap.RemoveAction |
instantiateRemoveAction() Factory for RemoveAction |
protected SegmentedConcurrentMap.SizeAction |
instantiateSizeAction() Factory for SizeAction |
protected SegmentedConcurrentMap.UnlockAction |
instantiateUnlockAction() Factory for UnlockAction |
boolean |
isEmpty() Returns true if this map contains no key-value mappings. |
boolean |
lock(java.lang.Object oKey) Attempt to lock the specified item and return immediately. |
boolean |
lock(java.lang.Object oKey, long cWait) Attempt to lock the specified item within the specified period of time. |
java.lang.Object |
putIfAbsent(java.lang.Object oKey, java.lang.Object oValue) If the specified key is not already associated with a value, associate it with the given value. |
boolean |
remove(java.lang.Object oKey, java.lang.Object oValue) Remove entry for key only if currently mapped to given value. |
java.lang.Object |
replace(java.lang.Object oKey, java.lang.Object oValue) Replace entry for key only if currently mapped to some value. |
boolean |
replace(java.lang.Object oKey, java.lang.Object oValueOld, java.lang.Object oValueNew) Replace entry for key only if currently mapped to given value. |
protected void |
setConditionalRemoveAction(SegmentedConcurrentMap.ConditionalRemoveAction action) Specify the action for conditional remove. |
protected void |
setContentionObserver(SegmentedConcurrentMap.ContentionObserver contentionObserver) Set the ContentionObserver for this SegmentedConcurrentMap. |
protected void |
setLockAction(SegmentedConcurrentMap.LockAction action) Specify the action for lock(). |
protected void |
setSizeAction(SegmentedConcurrentMap.SizeAction action) Specify the action for size(). |
protected void |
setUnlockAction(SegmentedConcurrentMap.UnlockAction action) Specify the action for unlock(). |
int |
size() Returns the number of key-value mappings in this map. |
boolean |
unlock(java.lang.Object oKey) Unlock the specified item. |
Methods inherited from interface com.tangosol.util.ConcurrentMap |
---|
containsKey, containsValue, get, put, putAll, remove |
Methods inherited from interface java.util.Map |
---|
entrySet, equals, hashCode, keySet, values |
Field Detail |
---|
protected static java.util.concurrent.atomic.AtomicReferenceFieldUpdater m_atomicUpdaterValue
protected Gate m_gateLockAll
protected SegmentedConcurrentMap.LockAction m_actionLock
protected SegmentedConcurrentMap.UnlockAction m_actionUnlock
protected SegmentedConcurrentMap.SizeAction m_actionSize
protected SegmentedConcurrentMap.ConditionalRemoveAction m_actionConditionalRemove
protected SegmentedConcurrentMap.ContentionObserver m_contentionObserver
Constructor Detail |
---|
public SegmentedConcurrentMap()
public SegmentedConcurrentMap(SegmentedConcurrentMap.ContentionObserver contentionObserver)
contentionObserver
- the ContentionObserverpublic SegmentedConcurrentMap(int cInitialBuckets, float flLoadFactor, float flGrowthRate)
cInitialBuckets
- the initial number of hash buckets, 0 < nflLoadFactor
- the acceptable load factor before resizing occurs, 0 < n, such that a load factor of 1.0 causes resizing when the number of entries exceeds the number of bucketsflGrowthRate
- the rate of bucket growth when a resize occurs, 0 < n, such that a growth rate of 1.0 will double the number of buckets: bucketcount = bucketcount * (1 + growthrate)public SegmentedConcurrentMap(int cInitialBuckets, float flLoadFactor, float flGrowthRate, SegmentedConcurrentMap.ContentionObserver contentionObserver)
cInitialBuckets
- the initial number of hash buckets, 0 < nflLoadFactor
- the acceptable load factor before resizing occurs, 0 < n, such that a load factor of 1.0 causes resizing when the number of entries exceeds the number of bucketsflGrowthRate
- the rate of bucket growth when a resize occurs, 0 < n, such that a growth rate of 1.0 will double the number of buckets: bucketcount = bucketcount * (1 + growthrate)contentionObserver
- the ContentionObserverMethod Detail |
---|
protected SegmentedConcurrentMap.LockAction getLockAction()
protected void setLockAction(SegmentedConcurrentMap.LockAction action)
action
- the action for lock()protected SegmentedConcurrentMap.UnlockAction getUnlockAction()
protected void setUnlockAction(SegmentedConcurrentMap.UnlockAction action)
action
- the action for unlock()protected SegmentedConcurrentMap.SizeAction getSizeAction()
protected void setSizeAction(SegmentedConcurrentMap.SizeAction action)
action
- the action for size()protected SegmentedConcurrentMap.ConditionalRemoveAction getConditionalRemoveAction()
protected void setConditionalRemoveAction(SegmentedConcurrentMap.ConditionalRemoveAction action)
action
- the action for conditional removepublic SegmentedConcurrentMap.ContentionObserver getContentionObserver()
protected void setContentionObserver(SegmentedConcurrentMap.ContentionObserver contentionObserver)
contentionObserver
- the contentionObserverpublic void clear()
clear
in interface java.util.Map
clear
in class SegmentedHashMap
public int size()
Note: Unlike some Map implementations, the size() operation on this map may be relatively expensive.
size
in interface java.util.Map
size
in class SegmentedHashMap
public boolean isEmpty()
isEmpty
in interface java.util.Map
isEmpty
in class SegmentedHashMap
public java.lang.Object putIfAbsent(java.lang.Object oKey, java.lang.Object oValue)
if (!map.containsKey(key)) return map.put(key, value); else return map.get(key);Except that the action is performed atomically.
putIfAbsent
in interface java.util.concurrent.ConcurrentMap
oKey
- key with which the specified value is to be associated.oValue
- value to be associated with the specified key.public boolean replace(java.lang.Object oKey, java.lang.Object oValueOld, java.lang.Object oValueNew)
if ((map.containsKey(key) && map.get(key).equals(oldValue)) { map.put(key, newValue); return true; } else return false;except that the action is performed atomically.
replace
in interface java.util.concurrent.ConcurrentMap
oKey
- key with which the specified value is associated.oValueOld
- value expected to be associated with the specified key.oValueNew
- value to be associated with the specified key.public java.lang.Object replace(java.lang.Object oKey, java.lang.Object oValue)
if ((map.containsKey(key)) { return map.put(key, value); } else return null;except that the action is performed atomically.
replace
in interface java.util.concurrent.ConcurrentMap
oKey
- key with which the specified value is associated.oValue
- value to be associated with the specified key.public boolean remove(java.lang.Object oKey, java.lang.Object oValue)
if ((map.containsKey(key) && map.get(key).equals(value)) { map.remove(key); return true; } else return false;except that the action is performed atomically.
remove
in interface java.util.concurrent.ConcurrentMap
oKey
- key with which the specified value is associated.oValue
- value associated with the specified key.public boolean lock(java.lang.Object oKey)
This method behaves exactly as if it simply performs the call lock(oKey, 0).
oKey
- key being lockedpublic boolean lock(java.lang.Object oKey, long cWait)
The item doesn't have to exist to be locked. While the item is locked there is known to be a lock holder which has an exclusive right to modify (calling put and remove methods) that item.
Lock holder is an abstract concept that depends on the ConcurrentMap implementation. For example, holder could be a cluster member or a thread (or both).
Locking strategy may vary for concrete implementations as well. Lock could have an expiration time (this lock is sometimes called a "lease") or be held indefinitely (until the lock holder terminates).
Some implementations may allow the entire map to be locked. If the map is locked in such a way, then only a lock holder is allowed to perform any of the "put" or "remove" operations. Pass the special constant ConcurrentMap.LOCK_ALL
as the oKey parameter to indicate the map lock.
oKey
- key being lockedcWait
- the number of milliseconds to continue trying to obtain a lock; pass zero to return immediately; pass -1 to block the calling thread until the lock could be obtainedpublic boolean unlock(java.lang.Object oKey)
oKey
- key being unlockedprotected void initializeActions()
initializeActions
in class SegmentedHashMap
protected SegmentedHashMap.RemoveAction instantiateRemoveAction()
instantiateRemoveAction
in class SegmentedHashMap
protected SegmentedConcurrentMap.ConditionalRemoveAction instantiateConditionalRemoveAction()
protected SegmentedConcurrentMap.LockAction instantiateLockAction()
protected SegmentedConcurrentMap.UnlockAction instantiateUnlockAction()
protected SegmentedConcurrentMap.SizeAction instantiateSizeAction()
protected SegmentedHashMap.Entry instantiateEntry(java.lang.Object oKey, java.lang.Object oValue, int nHash)
instantiateEntry
in class SegmentedHashMap
oKey
- the keyoValue
- the valuenHash
- the hashCode value of the key
|
Oracle® Coherence Java API Reference Release 3.7.1.0 E22843-01 |
|||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |