Skip navigation links

com.tangosol.util
Class SegmentedConcurrentMap

java.lang.Object
com.tangosol.util.Base
com.tangosol.util.SegmentedHashMap
com.tangosol.util.SegmentedConcurrentMap

All Implemented Interfaces:

java.util.concurrent.ConcurrentMap, java.util.Map

public class SegmentedConcurrentMap

extends SegmentedHashMap

implements ConcurrentMap, java.util.concurrent.ConcurrentMap

An implementation of SegmentedHashMap that also implements the ConcurrentMap interface.

See ConcurrentMap

Since:

Coherence 3.5

Author:

rhl 2008.12.01

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 class com.tangosol.util.SegmentedHashMap

BIGGEST_MODULO, DEFAULT_GROWTHRATE, DEFAULT_INITIALSIZE, DEFAULT_LOADFACTOR, LOCK_ALL_PENDING, LOCK_ALL_PENDING_IDX, LOCK_COUNT, LOCKS_ALL, LOCKS_NONE, m_actionContainsValue, m_actionGetEntry, m_actionInsert, m_actionRemove, m_aeBucket, m_aSegment, m_atomicLocks, m_colValues, m_cSegmentCapacity, m_flGrowthRate, m_flLoadFactor, m_oIterActive, m_setEntries, m_setKeys, MIN_SEGMENT_CAPACITY, NO_VALUE, PRIME_MODULO, PUTALL_THRESHOLD, RESIZING, SEGMENT_COUNT, SEGMENT_LOCK_MAX_SPIN

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)
boolean	remove(java.lang.Object oKey, java.lang.Object oValue)
java.lang.Object	replace(java.lang.Object oKey, java.lang.Object oValue)
boolean	replace(java.lang.Object oKey, java.lang.Object oValueOld, java.lang.Object oValueNew)
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 class com.tangosol.util.SegmentedHashMap

containsKey, containsValue, contendForSegment, ensureLoadFactor, entryFromBucket, entrySet, equals, get, getBucketIndex, getContainsValueAction, getEntry, getEntryInternal, getEntryInternal, getGetEntryAction, getInsertAction, getRemoveAction, getSegmentForKey, getSegmentIndex, getStableBucketArray, grow, grow, hashCode, instantiateContainsValueAction, instantiateEntrySet, instantiateGetEntryAction, instantiateInsertAction, instantiateKeySet, instantiateValuesCollection, invokeOnAllKeys, invokeOnKey, isActiveIterator, iteratorActivated, keySet, lockAllBuckets, lockAllBuckets, lockAllSegments, lockBucket, lockSegment, put, putAll, putInternal, putInternal, releaseIterator, remove, removeInternal, setContainsValueAction, setGetEntryAction, setInsertAction, setRemoveAction, toArrayInternal, toString, unlockAllBuckets, unlockAllBuckets, unlockAllSegments, unlockBucket, unlockSegment, values

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

m_atomicUpdaterValue

protected static java.util.concurrent.atomic.AtomicReferenceFieldUpdater m_atomicUpdaterValue

AtomicUpdater for the entry value.

m_gateLockAll

protected Gate m_gateLockAll

The Gate controlling LOCK_ALL access for this map.

m_actionLock

protected SegmentedConcurrentMap.LockAction m_actionLock

The action for lock() support.

m_actionUnlock

protected SegmentedConcurrentMap.UnlockAction m_actionUnlock

The action for unlock() support.

m_actionSize

protected SegmentedConcurrentMap.SizeAction m_actionSize

The singleton action for size support.

m_actionConditionalRemove

protected SegmentedConcurrentMap.ConditionalRemoveAction m_actionConditionalRemove

The singleton action for conditional remove.

m_contentionObserver

protected SegmentedConcurrentMap.ContentionObserver m_contentionObserver

The ContentionObserver; may be null.

Constructor Detail

SegmentedConcurrentMap

public SegmentedConcurrentMap()

Default constructor.

SegmentedConcurrentMap

public SegmentedConcurrentMap(SegmentedConcurrentMap.ContentionObserver contentionObserver)

Construct a SegmentedConcurrentMap with the default settings and the specified ContentionObserver

Parameters:

contentionObserver - the ContentionObserver

SegmentedConcurrentMap

public SegmentedConcurrentMap(int cInitialBuckets,
                              float flLoadFactor,
                              float flGrowthRate)

Construct a SegmentedConcurrentMap using the specified settings.

Parameters:

cInitialBuckets - the initial number of hash buckets, 0 < n

flLoadFactor - 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 buckets

flGrowthRate - 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)

SegmentedConcurrentMap

public SegmentedConcurrentMap(int cInitialBuckets,
                              float flLoadFactor,
                              float flGrowthRate,
                              SegmentedConcurrentMap.ContentionObserver contentionObserver)

Construct a thread-safe hash map using the specified settings.

Parameters:

cInitialBuckets - the initial number of hash buckets, 0 < n

flLoadFactor - 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 buckets

flGrowthRate - 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 ContentionObserver

Method Detail

getLockAction

protected SegmentedConcurrentMap.LockAction getLockAction()

Return the registered action for lock().

Returns:

the registered action for lock()

setLockAction

protected void setLockAction(SegmentedConcurrentMap.LockAction action)

Specify the action for lock().

Parameters:

action - the action for lock()

getUnlockAction

protected SegmentedConcurrentMap.UnlockAction getUnlockAction()

Return the registered action for unlock().

Returns:

the registered action for unlock()

setUnlockAction

protected void setUnlockAction(SegmentedConcurrentMap.UnlockAction action)

Specify the action for unlock().

Parameters:

action - the action for unlock()

getSizeAction

protected SegmentedConcurrentMap.SizeAction getSizeAction()

Return the registered action for size().

Returns:

the registered action for size()

setSizeAction

protected void setSizeAction(SegmentedConcurrentMap.SizeAction action)

Specify the action for size().

Parameters:

action - the action for size()

getConditionalRemoveAction

protected SegmentedConcurrentMap.ConditionalRemoveAction getConditionalRemoveAction()

Return the registered action for conditional remove.

Returns:

the registered action for conditional remove

setConditionalRemoveAction

protected void setConditionalRemoveAction(SegmentedConcurrentMap.ConditionalRemoveAction action)

Specify the action for conditional remove.

Parameters:

action - the action for conditional remove

getContentionObserver

public SegmentedConcurrentMap.ContentionObserver getContentionObserver()

Return the ContentionObserver for this SegmentedConcurrentMap.

Returns:

the ContentionObserver

setContentionObserver

protected void setContentionObserver(SegmentedConcurrentMap.ContentionObserver contentionObserver)

Set the ContentionObserver for this SegmentedConcurrentMap.

Parameters:

contentionObserver - the contentionObserver

clear

public void clear()

Removes all mappings from this map.

Specified by:

clear in interface java.util.Map

Overrides:

clear in class SegmentedHashMap

size

public int size()

Returns the number of key-value mappings in this map.

Note: Unlike some Map implementations, the size() operation on this map may be relatively expensive.

Specified by:

size in interface java.util.Map

Overrides:

size in class SegmentedHashMap

Returns:

the number of key-value mappings in this map

isEmpty

public boolean isEmpty()

Returns true if this map contains no key-value mappings.

Specified by:

isEmpty in interface java.util.Map

Overrides:

isEmpty in class SegmentedHashMap

Returns:

true if this map contains no key-value mappings

putIfAbsent

public java.lang.Object putIfAbsent(java.lang.Object oKey,
                                    java.lang.Object oValue)

Specified by:

putIfAbsent in interface java.util.concurrent.ConcurrentMap

replace

public boolean replace(java.lang.Object oKey,
                       java.lang.Object oValueOld,
                       java.lang.Object oValueNew)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap

replace

public java.lang.Object replace(java.lang.Object oKey,
                                java.lang.Object oValue)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap

remove

public boolean remove(java.lang.Object oKey,
                      java.lang.Object oValue)

Specified by:

remove in interface java.util.concurrent.ConcurrentMap

lock

public boolean lock(java.lang.Object oKey)

Attempt to lock the specified item and return immediately.

This method behaves exactly as if it simply performs the call lock(oKey, 0).

Parameters:

oKey - key being locked

Returns:

true if the item was successfully locked; false otherwise

lock

public boolean lock(java.lang.Object oKey,
                    long cWait)

Attempt to lock the specified item within the specified period of time.

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.

Parameters:

oKey - key being locked

cWait - 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 obtained

Returns:

true if the item was successfully locked within the specified time; false otherwise

unlock

public boolean unlock(java.lang.Object oKey)

Unlock the specified item. The item doesn't have to exist to be unlocked. If the item is currently locked, only the holder of the lock could successfully unlock it.

Parameters:

oKey - key being unlocked

Returns:

true if the item was successfully unlocked; false otherwise

initializeActions

protected void initializeActions()

Initialize the EntryAction's for this map.

Overrides:

initializeActions in class SegmentedHashMap

instantiateRemoveAction

protected SegmentedHashMap.RemoveAction instantiateRemoveAction()

Factory for RemoveAction

Overrides:

instantiateRemoveAction in class SegmentedHashMap

Returns:

a RemoveAction

instantiateConditionalRemoveAction

protected SegmentedConcurrentMap.ConditionalRemoveAction instantiateConditionalRemoveAction()

Factory for ConditionalRemoveAction

Returns:

a ConditionalRemoveAction

instantiateLockAction

protected SegmentedConcurrentMap.LockAction instantiateLockAction()

Factory for LockAction

Returns:

a LockAction

instantiateUnlockAction

protected SegmentedConcurrentMap.UnlockAction instantiateUnlockAction()

Factory for UnlockAction

Returns:

an UnlockAction

instantiateSizeAction

protected SegmentedConcurrentMap.SizeAction instantiateSizeAction()

Factory for SizeAction

Returns:

a SizeAction

instantiateEntry

protected SegmentedHashMap.Entry instantiateEntry(java.lang.Object oKey,
                                                  java.lang.Object oValue,
                                                  int nHash)

Factory for Entry.

Overrides:

instantiateEntry in class SegmentedHashMap

Parameters:

oKey - the key

oValue - the value

nHash - the hashCode value of the key

Returns:

a new instance of the Entry class (or a subclass thereof)

Skip navigation links