Package com.tangosol.util

Class SegmentedConcurrentMap

java.lang.Object
com.tangosol.util.Base
com.tangosol.util.SegmentedHashMap
com.tangosol.util.SegmentedConcurrentMap
All Implemented Interfaces:
ConcurrentMap, ConcurrentMap, Map
public class SegmentedConcurrentMap extends SegmentedHashMap implements ConcurrentMap, ConcurrentMap
An implementation of SegmentedHashMap that also implements the ConcurrentMap interface.

See ConcurrentMap

Since:
Coherence 3.5
Author:
rhl 2008.12.01

  • Field Details

  • Constructor Details

    • 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 Details

    • 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 ConcurrentMap
      Specified by:
      clear in interface 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 ConcurrentMap
      Specified by:
      size in interface 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 ConcurrentMap
      Specified by:
      isEmpty in interface Map
      Overrides:
      isEmpty in class SegmentedHashMap
      Returns:
      true if this map contains no key-value mappings

    • putIfAbsent

      public Object putIfAbsent(Object oKey, Object oValue)
      Specified by:
      putIfAbsent in interface ConcurrentMap
      Specified by:
      putIfAbsent in interface Map

    • replace

      public boolean replace(Object oKey, Object oValueOld, Object oValueNew)
      Specified by:
      replace in interface ConcurrentMap
      Specified by:
      replace in interface Map

    • replace

      public Object replace(Object oKey, Object oValue)
      Specified by:
      replace in interface ConcurrentMap
      Specified by:
      replace in interface Map

    • remove

      public boolean remove(Object oKey, Object oValue)
      Specified by:
      remove in interface ConcurrentMap
      Specified by:
      remove in interface Map

    • lock

      public boolean lock(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).

      Specified by:
      lock in interface ConcurrentMap
      Parameters:
      oKey - key being locked
      Returns:
      true if the item was successfully locked; false otherwise

    • lock

      public boolean lock(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.

      Specified by:
      lock in interface ConcurrentMap
      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(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.
      Specified by:
      unlock in interface ConcurrentMap
      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(Object oKey, 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)