CustomConcurrentHashMap (org.codehaus.gpars)

groovyx.gpars.extra166y.CustomConcurrentHashMap

All Implemented Interfaces and Traits:

java.util.concurrent.ConcurrentMap, java.io.Serializable
```
public class CustomConcurrentHashMap
extends java.util.AbstractMap
```
A java.util.ConcurrentMap supporting user-defined equivalence comparisons, soft, weak, or strong keys and values, and user-supplied computational methods for setting and updating values. In particular:
- Identity-based, Equality-based or User-definable Equivalence-based comparisons controlling membership.
- {
  linkplain:
  SoftReference Soft}, {@linkplain WeakReference weak} or strong (regular) keys and values.
  User-definable MappingFunctions that may be used in method CustomConcurrentHashMap.computeIfAbsent to atomically establish a computed value, along with RemappingFunctions that can be used in method CustomConcurrentHashMap.compute to atomically replace values.
  Factory methods returning specialized forms for int keys and/or values, that may be more space-efficient
Per-map settings are established in constructors, as in the following usages (that assume static imports to simplify expression of configuration parameters):
```
 identityMap = new CustomConcurrentHashMap<Person,Salary>
     (STRONG, IDENTITY, STRONG, EQUALS, 0);
 weakKeyMap = new CustomConcurrentHashMap<Person,Salary>
     (WEAK, IDENTITY, STRONG, EQUALS, 0);
     .weakKeys());
 byNameMap = new CustomConcurrentHashMap<Person,Salary>
     (STRONG,
      new Equivalence<Person>() {
          public boolean equal(Person k, Object x) {
            return x instanceof Person && k.name.equals(((Person)x).name);
          
          public int hash(Object x) {
             return (x instanceof Person) ? ((Person)x).name.hashCode() : 0;
          }
        },
      STRONG, EQUALS, 0);
 }
 
```
The first usage above provides a replacement for java.util.IdentityHashMap, and the second a replacement for java.util.WeakHashMap, adding concurrency, asynchronous cleanup, and identity-based equality for keys. The third usage illustrates a map with a custom Equivalence that looks only at the name field of a (fictional) Person class.
This class also includes nested class KeySet that provides space-efficient Set views of maps, also supporting method intern, which may be of use in canonicalizing elements.
When used with (Weak or Soft) Reference keys and/or values, elements that have asynchronously become null are treated as absent from the map and (eventually) removed from maps via a background thread common across all maps. Because of the potential for asynchronous clearing of References, methods such as containsValue have weaker guarantees than you might expect even in the absence of other explicitly concurrent operations. For example containsValue(value) may return true even if value is no longer available upon return from the method.
When Equivalences other than equality are used, the returned collections may violate the specifications of Map and/or Set interfaces, which mandate the use of the equals method when comparing objects. The methods of this class otherwise have properties similar to those of java.util.ConcurrentHashMap under its default settings. To adaptively maintain semantics and performance under varying conditions, this class does not support load factor or concurrency level parameters. This class does not permit null keys or values. This class is serializable; however, serializing a map that uses soft or weak references can give unpredictable results. This class supports all optional operations of the ConcurrentMap interface. It supports have weakly consistent iteration: an iterator over one of the map's view collections may reflect some, all or none of the changes made to the collection after the iterator was created.
This class is a member of the Java Collections Framework.
Parameters:
- the type of keys maintained by this map
- the type of mapped values

Nested Class Summary

Nested classes
Modifiers	Name	Description
`static class`	`CustomConcurrentHashMap.EmbeddedSoftReference`
`static class`	`CustomConcurrentHashMap.EmbeddedWeakReference`
`class`	`CustomConcurrentHashMap.EntryIterator`
`class`	`CustomConcurrentHashMap.EntrySet`
`static interface`	`CustomConcurrentHashMap.Equivalence`	An object performing equality comparisons, along with a hash function consistent with this comparison.
`static class`	`CustomConcurrentHashMap.EquivalenceUsingEquals`
`static class`	`CustomConcurrentHashMap.EquivalenceUsingIdentity`
`class`	`CustomConcurrentHashMap.HashIterator`
`static class`	`CustomConcurrentHashMap.IntKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.IntKeyIntValueNodeFactory`
`static class`	`CustomConcurrentHashMap.IntKeyNode`
`static class`	`CustomConcurrentHashMap.IntKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.IntKeySelfValueNodeFactory`
`static class`	`CustomConcurrentHashMap.IntKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.IntKeySoftValueNodeFactory`
`static class`	`CustomConcurrentHashMap.IntKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.IntKeyStrongValueNodeFactory`
`static class`	`CustomConcurrentHashMap.IntKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.IntKeyWeakValueNodeFactory`
`class`	`CustomConcurrentHashMap.KeyIterator`
`static class`	`CustomConcurrentHashMap.KeySet`	A hash-based set with properties identical to those of `Collections.newSetFromMap` applied to a `CustomConcurrentHashMap`, but possibly more space-efficient.
`class`	`CustomConcurrentHashMap.KeySetView`
`static class`	`CustomConcurrentHashMap.LinkedIntKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.LinkedIntKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.LinkedIntKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.LinkedIntKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.LinkedIntKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.LinkedSoftKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.LinkedSoftKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.LinkedSoftKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.LinkedSoftKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.LinkedSoftKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.LinkedStrongKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.LinkedStrongKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.LinkedStrongKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.LinkedStrongKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.LinkedStrongKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.LinkedWeakKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.LinkedWeakKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.LinkedWeakKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.LinkedWeakKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.LinkedWeakKeyWeakValueNode`
`static interface`	`CustomConcurrentHashMap.MappingFunction`	A function computing a mapping from the given key to a value, or `null` if there is no mapping.
`static interface`	`CustomConcurrentHashMap.Node`	An object maintaining a key-value mapping.
`static interface`	`CustomConcurrentHashMap.NodeFactory`	A factory for Nodes.
`static interface`	`CustomConcurrentHashMap.Reclaimable`	An object that may be subject to cleanup operations when removed from a java.lang.ref.ReferenceQueue
`static class`	`CustomConcurrentHashMap.ReclamationThread`
`static interface`	`CustomConcurrentHashMap.RemappingFunction`	A function computing a new mapping from the given key and its current value to a new value, or `null` if there is no mapping.
`static class`	`CustomConcurrentHashMap.Segment`	Each Segment holds a count and table corresponding to a segment of the table.
`static class`	`CustomConcurrentHashMap.SoftKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.SoftKeyIntValueNodeFactory`
`static class`	`CustomConcurrentHashMap.SoftKeyNode`
`static class`	`CustomConcurrentHashMap.SoftKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.SoftKeySelfValueNodeFactory`
`static class`	`CustomConcurrentHashMap.SoftKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.SoftKeySoftValueNodeFactory`
`static class`	`CustomConcurrentHashMap.SoftKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.SoftKeyStrongValueNodeFactory`
`static class`	`CustomConcurrentHashMap.SoftKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.SoftKeyWeakValueNodeFactory`
`enum`	`CustomConcurrentHashMap.Strength`	The strength of keys and values that may be held by maps. strong denotes ordinary objects. weak and soft denote the corresponding java.lang.ref.Reference types.
`static class`	`CustomConcurrentHashMap.StrongKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.StrongKeyIntValueNodeFactory`
`static class`	`CustomConcurrentHashMap.StrongKeyNode`
`static class`	`CustomConcurrentHashMap.StrongKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.StrongKeySelfValueNodeFactory`
`static class`	`CustomConcurrentHashMap.StrongKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.StrongKeySoftValueNodeFactory`
`static class`	`CustomConcurrentHashMap.StrongKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.StrongKeyStrongValueNodeFactory`
`static class`	`CustomConcurrentHashMap.StrongKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.StrongKeyWeakValueNodeFactory`
`static class`	`CustomConcurrentHashMap.TerminalIntKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.TerminalIntKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.TerminalIntKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.TerminalIntKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.TerminalIntKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.TerminalSoftKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.TerminalSoftKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.TerminalSoftKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.TerminalSoftKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.TerminalSoftKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.TerminalStrongKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.TerminalStrongKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.TerminalStrongKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.TerminalStrongKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.TerminalStrongKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.TerminalWeakKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.TerminalWeakKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.TerminalWeakKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.TerminalWeakKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.TerminalWeakKeyWeakValueNode`
`class`	`CustomConcurrentHashMap.ValueIterator`
`class`	`CustomConcurrentHashMap.Values`
`static class`	`CustomConcurrentHashMap.WeakKeyIntValueNode`
`static class`	`CustomConcurrentHashMap.WeakKeyIntValueNodeFactory`
`static class`	`CustomConcurrentHashMap.WeakKeyNode`
`static class`	`CustomConcurrentHashMap.WeakKeySelfValueNode`
`static class`	`CustomConcurrentHashMap.WeakKeySelfValueNodeFactory`
`static class`	`CustomConcurrentHashMap.WeakKeySoftValueNode`
`static class`	`CustomConcurrentHashMap.WeakKeySoftValueNodeFactory`
`static class`	`CustomConcurrentHashMap.WeakKeyStrongValueNode`
`static class`	`CustomConcurrentHashMap.WeakKeyStrongValueNodeFactory`
`static class`	`CustomConcurrentHashMap.WeakKeyWeakValueNode`
`static class`	`CustomConcurrentHashMap.WeakKeyWeakValueNodeFactory`
`class`	`CustomConcurrentHashMap.WriteThroughEntry`

Field Summary

Fields
Modifiers	Name	Description
`static Equivalence<java.lang.Object>`	`EQUALS`	An Equivalence object performing java.lang.Object#equals based comparisons and using java.lang.Object#hashCode hashing
`static Equivalence<java.lang.Object>`	`IDENTITY`	An Equivalence object performing identity-based comparisons and using java.lang.System#identityHashCode for hashing
`private static java.lang.String`	`INT_STRING`	Config string for int maps
`static int`	`MAX_SEGMENT_CAPACITY`
`static int`	`MIN_SEGMENT_CAPACITY`
`static int`	`NSEGMENTS`
`static int`	`SEGMENT_BITS`
`static int`	`SEGMENT_MASK`
`static int`	`SEGMENT_SHIFT`
`private static java.lang.String`	`SELF_STRING`	Config string for self-map (Set view) refs
`static CustomConcurrentHashMap.Strength`	`SOFT`	The strength of soft references
`static CustomConcurrentHashMap.Strength`	`STRONG`	The strength of ordinary references
`static sun.misc.Unsafe`	`UNSAFE`
`static CustomConcurrentHashMap.Strength`	`WEAK`	The strength of weak references
`java.util.Set<Map.Entry<K, V>>`	`entrySet`
`CustomConcurrentHashMap.NodeFactory`	`factory`	The factory for this map
`int`	`initialSegmentCapacity`	The initial size of Segment tables when they are first constructed
`Equivalence<? super K>`	`keyEquivalence`	Equivalence object for keys
`java.util.Set<K>`	`keySet`
`static java.lang.ref.ReferenceQueue<java.lang.Object>`	`refQueue`
`CustomConcurrentHashMap.Segment[]`	`segments`	The segments, each of which acts as a hash table
`static long`	`segmentsBase`
`static int`	`segmentsShift`
`private static long`	`serialVersionUID`
`static long`	`tableBase`
`static int`	`tableShift`
`Equivalence<? super V>`	`valueEquivalence`	Equivalence object for values
`java.util.Collection<V>`	`values`

Constructor Summary

Constructors
Constructor and description
`CustomConcurrentHashMap ()`

Methods Summary

Methods
Type	Name and description
`java.lang.Object`	`CustomConcurrentHashMap(java.lang.String ks, Equivalence<? super K> keq, java.lang.String vs, Equivalence<? super V> veq, int expectedSize)` Internal constructor to set factory, equivalences and segment capacities, and to create segments array.
`java.lang.Object`	`CustomConcurrentHashMap(CustomConcurrentHashMap.Strength keyStrength, Equivalence<? super K> keyEquivalence, CustomConcurrentHashMap.Strength valueStrength, Equivalence<? super V> valueEquivalence, int expectedSize)` Creates a new CustomConcurrentHashMap with the given parameters.
`java.lang.Object`	`CustomConcurrentHashMap()` Creates a new CustomConcurrentHashMap with strong keys and values, and equality-based equivalence.
`void`	`clear()` Removes all of the mappings from this map.
`V`	`compute(K key, RemappingFunction<? super K, V> remappingFunction)` Updates the mapping for the given key with the result of the given remappingFunction.
`V`	`computeIfAbsent(K key, MappingFunction<? super K, ? extends V> mappingFunction)` If the specified key is not already associated with a value, computes its value using the given mappingFunction, and if non-null, enters it into the map.
`boolean`	`containsKey(java.lang.Object key)` Returns `true` if this map contains a key equivalent to the given key with respect to this map's key Equivalence.
`boolean`	`containsValue(java.lang.Object value)` Returns `true` if this map maps one or more keys to a value equivalent to the given value with respect to this map's value Equivalence.
`V`	`doPut(K key, V value, boolean onlyIfNull)` Shared implementation for put, putIfAbsent
`java.util.Set<Map.Entry<K, V>>`	`entrySet()` Returns a java.util.Set view of the mappings contained in this map.
`boolean`	`equals(java.lang.Object o)` Compares the specified object with this map for equality.
`CustomConcurrentHashMap.Node`	`findNode(java.lang.Object key, int hash, CustomConcurrentHashMap.Segment seg)` Returns node for key, or null if none.
`V`	`get(java.lang.Object key)` Returns the value associated with a key equivalent to the given key with respect to this map's key Equivalence, or `null` if no such mapping exists.
`static java.lang.ref.ReferenceQueue<java.lang.Object>`	`getReclamationQueue()` Returns a queue that may be used as the ReferenceQueue argument to java.lang.ref.Reference constructors to arrange removal of reclaimed nodes from maps via a background thread.
`CustomConcurrentHashMap.Segment`	`getSegmentForAdd(int hash)` Returns the segment for possibly inserting into the table associated with given hash, constructing it if necessary.
`CustomConcurrentHashMap.Segment`	`getSegmentForTraversal(int hash)` Returns the segment for traversing table for key with given hash.
`private static sun.misc.Unsafe`	`getUnsafe()` Returns a sun.misc.Unsafe.
`int`	`hashCode()` Returns the sum of the hash codes of each entry in this map's `entrySet()` view, which in turn are the hash codes computed using key and value Equivalences for this Map.
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`CustomConcurrentHashMap.KeyIterator`	`keyIterator()`
`java.util.Set<K>`	`keySet()` Returns a java.util.Set view of the keys contained in this map.
`static CustomConcurrentHashMap<java.lang.Integer, java.lang.Integer>`	`newIntKeyIntValueMap(int expectedSize)` Returns a new map using Integer keys and values.
`static CustomConcurrentHashMap<java.lang.Integer, ValueType>`	`newIntKeyMap(CustomConcurrentHashMap.Strength valueStrength, Equivalence<? super ValueType> valueEquivalence, int expectedSize)` Returns a new map using Integer keys and the given value parameters.
`static CustomConcurrentHashMap<KeyType, java.lang.Integer>`	`newIntValueMap(CustomConcurrentHashMap.Strength keyStrength, Equivalence<? super KeyType> keyEquivalence, int expectedSize)` Returns a new map using the given key parameters and Integer values.
`V`	`put(K key, V value)` Maps the specified key to the specified value in this map.
`void`	`putAll(java.util.Map<? extends K, ? extends V> m)` Copies all of the mappings from the specified map to this one.
`V`	`putIfAbsent(K key, V value)` {@inheritDoc}
`private void`	`readObject(java.io.ObjectInputStream s)` Reconstitutes the instance from a stream (that is, deserializes it).
`V`	`remove(java.lang.Object key)` Removes the mapping for the specified key.
`boolean`	`remove(java.lang.Object key, java.lang.Object value)` {@inheritDoc}
`void`	`removeIfReclaimed(CustomConcurrentHashMap.Node r)` Removes node if its key or value are null.
`V`	`replace(K key, V value)` {@inheritDoc}
`boolean`	`replace(K key, V oldValue, V newValue)` {@inheritDoc}
`int`	`size()` Returns the number of key-value mappings in this map.
`static int`	`spreadHash(int h)` Applies a supplemental hash function to a given hashCode, which defends against poor quality hash functions.
`static java.lang.ref.ReferenceQueue<java.lang.Object>`	`startReclamation()`
`static void`	`storeNode(CustomConcurrentHashMap.Node[] table, int i, CustomConcurrentHashMap.Node r)`
`static void`	`storeSegment(CustomConcurrentHashMap.Segment[] segs, int i, CustomConcurrentHashMap.Segment s)`
`CustomConcurrentHashMap`	`valueOf(java.lang.String name)` Returns the enum constant of this type with the specified name.
`CustomConcurrentHashMap[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`java.util.Collection<V>`	`values()` Returns a java.util.Collection view of the values contained in this map.
`private void`	`writeObject(java.io.ObjectOutputStream s)` Saves the state of the instance to a stream (i.e., serializes it).

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class java.util.AbstractMap`	java.util.AbstractMap#remove(java.lang.Object), java.util.AbstractMap#get(java.lang.Object), java.util.AbstractMap#put(java.lang.Object, java.lang.Object), java.util.AbstractMap#equals(java.lang.Object), java.util.AbstractMap#toString(), java.util.AbstractMap#values(), java.util.AbstractMap#hashCode(), java.util.AbstractMap#clear(), java.util.AbstractMap#isEmpty(), java.util.AbstractMap#size(), java.util.AbstractMap#entrySet(), java.util.AbstractMap#putAll(java.util.Map), java.util.AbstractMap#keySet(), java.util.AbstractMap#containsKey(java.lang.Object), java.util.AbstractMap#containsValue(java.lang.Object), java.util.AbstractMap#wait(), java.util.AbstractMap#wait(long, int), java.util.AbstractMap#wait(long), java.util.AbstractMap#getClass(), java.util.AbstractMap#notify(), java.util.AbstractMap#notifyAll(), java.util.AbstractMap#remove(java.lang.Object, java.lang.Object), java.util.AbstractMap#replace(java.lang.Object, java.lang.Object), java.util.AbstractMap#replace(java.lang.Object, java.lang.Object, java.lang.Object), java.util.AbstractMap#replaceAll(java.util.function.BiFunction), java.util.AbstractMap#putIfAbsent(java.lang.Object, java.lang.Object), java.util.AbstractMap#compute(java.lang.Object, java.util.function.BiFunction), java.util.AbstractMap#computeIfAbsent(java.lang.Object, java.util.function.Function), java.util.AbstractMap#computeIfPresent(java.lang.Object, java.util.function.BiFunction), java.util.AbstractMap#forEach(java.util.function.BiConsumer), java.util.AbstractMap#getOrDefault(java.lang.Object, java.lang.Object), java.util.AbstractMap#merge(java.lang.Object, java.lang.Object, java.util.function.BiFunction)
`class java.lang.Object`	`java.lang.Object#wait(), java.lang.Object#wait(long, int), java.lang.Object#wait(long), java.lang.Object#equals(java.lang.Object), java.lang.Object#toString(), java.lang.Object#hashCode(), java.lang.Object#getClass(), java.lang.Object#notify(), java.lang.Object#notifyAll()`

- Field Detail
  - public static final Equivalence<java.lang.Object> EQUALS
    
    An Equivalence object performing java.lang.Object#equals based comparisons and using java.lang.Object#hashCode hashing
  - public static final Equivalence<java.lang.Object> IDENTITY
    
    An Equivalence object performing identity-based comparisons and using java.lang.System#identityHashCode for hashing
  - private static final java.lang.String INT_STRING
    
    Config string for int maps
  - static final int MAX_SEGMENT_CAPACITY
  - static final int MIN_SEGMENT_CAPACITY
  - static final int NSEGMENTS
  - static final int SEGMENT_BITS
  - static final int SEGMENT_MASK
  - static final int SEGMENT_SHIFT
  - private static final java.lang.String SELF_STRING
    
    Config string for self-map (Set view) refs
  - public static final CustomConcurrentHashMap.Strength SOFT
    
    The strength of soft references
  - public static final CustomConcurrentHashMap.Strength STRONG
    
    The strength of ordinary references
  - static final sun.misc.Unsafe UNSAFE
  - public static final CustomConcurrentHashMap.Strength WEAK
    
    The strength of weak references
  - java.util.Set<Map.Entry<K, V>> entrySet
  - final CustomConcurrentHashMap.NodeFactory factory
    
    The factory for this map
  - final int initialSegmentCapacity
    
    The initial size of Segment tables when they are first constructed
  - final Equivalence<? super K> keyEquivalence
    
    Equivalence object for keys
  - java.util.Set<K> keySet
  - static java.lang.ref.ReferenceQueue<java.lang.Object> refQueue
  - CustomConcurrentHashMap.Segment[] segments
    
    The segments, each of which acts as a hash table
  - static final long segmentsBase
  - static final int segmentsShift
  - private static final long serialVersionUID
  - static final long tableBase
  - static final int tableShift
  - final Equivalence<? super V> valueEquivalence
    
    Equivalence object for values
  - java.util.Collection<V> values
- Constructor Detail
  - CustomConcurrentHashMap()
- Method Detail
  - java.lang.Object CustomConcurrentHashMap(java.lang.String ks, Equivalence<? super K> keq, java.lang.String vs, Equivalence<? super V> veq, int expectedSize)
    
    Internal constructor to set factory, equivalences and segment capacities, and to create segments array.
  - public java.lang.Object CustomConcurrentHashMap(CustomConcurrentHashMap.Strength keyStrength, Equivalence<? super K> keyEquivalence, CustomConcurrentHashMap.Strength valueStrength, Equivalence<? super V> valueEquivalence, int expectedSize)
    
    Creates a new CustomConcurrentHashMap with the given parameters.
    Parameters:
    keyStrength - the strength for keys
    keyEquivalence - the Equivalence to use for keys
    valueStrength - the strength for values
    valueEquivalence - the Equivalence to use for values
    expectedSize - an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.
  - public java.lang.Object CustomConcurrentHashMap()
    
    Creates a new CustomConcurrentHashMap with strong keys and values, and equality-based equivalence.
  - public final void clear()
    
    Removes all of the mappings from this map.
  - public V compute(K key, RemappingFunction<? super K, V> remappingFunction)
    
    Updates the mapping for the given key with the result of the given remappingFunction. This is equivalent to
```
   value = remappingFunction.remap(key, get(key));
   if (value != null)
     return put(key, value):
   else
     return remove(key);
 
```
    except that the action is performed atomically. Some attempted operations on this map by other threads may be blocked while computation is in progress.
    Sample Usage. A remapping function can be used to perform frequency counting of words using code such as:
```
 map.compute(word, new RemappingFunction<String,Integer>() {
   public Integer remap(String k, Integer v) {
     return (v == null) ? 1 : v + 1;
   }});
 
```
    throws:
    NullPointerException if the specified key or remappingFunction is null
    throws:
    RuntimeException or Error if the remappingFunction does so, in which case the mapping is left in its previous state
    
    Returns:
    the updated value or null if the computation returned null
    Parameters:
    key - key with which the specified value is to be associated
    remappingFunction - the function to compute a value
  - public V computeIfAbsent(K key, MappingFunction<? super K, ? extends V> mappingFunction)
    
    If the specified key is not already associated with a value, computes its value using the given mappingFunction, and if non-null, enters it into the map. This is equivalent to
```
   if (map.containsKey(key))
       return map.get(key);
   value = mappingFunction.map(key);
   if (value != null)
      return map.put(key, value);
   else
      return null;
 
```
    except that the action is performed atomically. Some attempted operations on this map by other threads may be blocked while computation is in progress. Because this function is invoked within atomicity control, the computation should be short and simple. The most common usage is to construct a new object serving as an initial mapped value, or memoized result.
    throws:
    NullPointerException if the specified key or mappingFunction is null
    throws:
    RuntimeException or Error if the mappingFunction does so, in which case the mapping is left unestablished
    
    Returns:
    the current (existing or computed) value associated with the specified key, or null if the computation returned null
    Parameters:
    key - key with which the specified value is to be associated
    mappingFunction - the function to compute a value
  - public boolean containsKey(java.lang.Object key)
    
    Returns true if this map contains a key equivalent to the given key with respect to this map's key Equivalence.
    throws:
    NullPointerException if the specified key is null
    
    Returns:
    true if this map contains the specified key
    Parameters:
    key - possible key
  - public final boolean containsValue(java.lang.Object value)
    
    Returns true if this map maps one or more keys to a value equivalent to the given value with respect to this map's value Equivalence. Note: This method requires a full internal traversal of the hash table, and so is much slower than method containsKey.
    throws:
    NullPointerException if the specified value is null
    
    Returns:
    true if this map maps one or more keys to the specified value
    Parameters:
    value - value whose presence in this map is to be tested
  - final V doPut(K key, V value, boolean onlyIfNull)
    
    Shared implementation for put, putIfAbsent
  - public java.util.Set<Map.Entry<K, V>> entrySet()
    
    Returns a java.util.Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
    The view's iterator is a "weakly consistent" iterator that will never throw java.util.ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
  - public boolean equals(java.lang.Object o)
    
    Compares the specified object with this map for equality. Returns true if the given object is also a map of the same size, holding keys that are equal using this Map's key Equivalence, and which map to values that are equal according to this Map's value equivalence.
    Returns:
    true if the specified object is equal to this map
    Parameters:
    o - object to be compared for equality with this map
  - final CustomConcurrentHashMap.Node findNode(java.lang.Object key, int hash, CustomConcurrentHashMap.Segment seg)
    
    Returns node for key, or null if none.
  - public V get(java.lang.Object key)
    
    Returns the value associated with a key equivalent to the given key with respect to this map's key Equivalence, or null if no such mapping exists.
    throws:
    NullPointerException if the specified key is null
    
    Returns:
    the value associated with the key, or null if there is no mapping
    Parameters:
    key - possible key
  - static java.lang.ref.ReferenceQueue<java.lang.Object> getReclamationQueue()
    
    Returns a queue that may be used as the ReferenceQueue argument to java.lang.ref.Reference constructors to arrange removal of reclaimed nodes from maps via a background thread.
    Returns:
    the reference queue associated with the background cleanup thread
  - final CustomConcurrentHashMap.Segment getSegmentForAdd(int hash)
    
    Returns the segment for possibly inserting into the table associated with given hash, constructing it if necessary.
    Returns:
    the segment
    Parameters:
    hash - the hash code for the key
  - final CustomConcurrentHashMap.Segment getSegmentForTraversal(int hash)
    
    Returns the segment for traversing table for key with given hash.
    Returns:
    the segment, or null if not yet initialized
    Parameters:
    hash - the hash code for the key
  - private static sun.misc.Unsafe getUnsafe()
    
    Returns a sun.misc.Unsafe. Suitable for use in a 3rd party package. Replace with a simple call to Unsafe.getUnsafe when integrating into a jdk.
    Returns:
    a sun.misc.Unsafe
  - public int hashCode()
    
    Returns the sum of the hash codes of each entry in this map's entrySet() view, which in turn are the hash codes computed using key and value Equivalences for this Map.
    Returns:
    the hash code
  - public final boolean isEmpty()
    
    Returns true if this map contains no key-value mappings.
    Returns:
    true if this map contains no key-value mappings
  - final CustomConcurrentHashMap.KeyIterator keyIterator()
  - public java.util.Set<K> keySet()
    
    Returns a java.util.Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. The set supports element removal, which removes the corresponding mapping from this map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
    The view's iterator is a "weakly consistent" iterator that will never throw java.util.ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
  - public static CustomConcurrentHashMap<java.lang.Integer, java.lang.Integer> newIntKeyIntValueMap(int expectedSize)
    
    Returns a new map using Integer keys and values.
    Returns:
    the map
    Parameters:
    expectedSize - an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.
  - public static CustomConcurrentHashMap<java.lang.Integer, ValueType> newIntKeyMap(CustomConcurrentHashMap.Strength valueStrength, Equivalence<? super ValueType> valueEquivalence, int expectedSize)
    
    Returns a new map using Integer keys and the given value parameters.
    Returns:
    the map
    Parameters:
    valueStrength - the strength for values
    valueEquivalence - the Equivalence to use for values
    expectedSize - an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.
  - public static CustomConcurrentHashMap<KeyType, java.lang.Integer> newIntValueMap(CustomConcurrentHashMap.Strength keyStrength, Equivalence<? super KeyType> keyEquivalence, int expectedSize)
    
    Returns a new map using the given key parameters and Integer values.
    Returns:
    the map
    Parameters:
    keyStrength - the strength for keys
    keyEquivalence - the Equivalence to use for keys
    expectedSize - an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.
  - public V put(K key, V value)
    
    Maps the specified key to the specified value in this map.
    throws:
    NullPointerException if the specified key or value is null
    
    Returns:
    the previous value associated with key, or null if there was no mapping for key
    Parameters:
    key - key with which the specified value is to be associated
    value - value to be associated with the specified key
  - public void putAll(java.util.Map<? extends K, ? extends V> m)
    
    Copies all of the mappings from the specified map to this one. These mappings replace any mappings that this map had for any of the keys currently in the specified map.
    Parameters:
    m - mappings to be stored in this map
  - public V putIfAbsent(K key, V value)
    
    {@inheritDoc}
    throws:
    NullPointerException if the specified key or value is null
    
    Returns:
    the previous value associated with the specified key, or null if there was no mapping for the key
  - private void readObject(java.io.ObjectInputStream s)
    
    Reconstitutes the instance from a stream (that is, deserializes it).
    Parameters:
    s - the stream
  - public V remove(java.lang.Object key)
    
    Removes the mapping for the specified key.
    throws:
    NullPointerException if the specified key is null
    
    Returns:
    the previous value associated with key, or null if there was no mapping for key
    Parameters:
    key - the key to remove
  - public boolean remove(java.lang.Object key, java.lang.Object value)
    
    {@inheritDoc}
    throws:
    NullPointerException if the specified key is null
  - final void removeIfReclaimed(CustomConcurrentHashMap.Node r)
    
    Removes node if its key or value are null.
  - public V replace(K key, V value)
    
    {@inheritDoc}
    throws:
    NullPointerException if any of the arguments are null
  - public boolean replace(K key, V oldValue, V newValue)
    
    {@inheritDoc}
    throws:
    NullPointerException if the specified key or value is null
    
    Returns:
    the previous value associated with the specified key, or null if there was no mapping for the key
  - public final int size()
    
    Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
    Returns:
    the number of key-value mappings in this map
  - static int spreadHash(int h)
    
    Applies a supplemental hash function to a given hashCode, which defends against poor quality hash functions. This is critical because we use power-of-two length hash tables, that otherwise encounter collisions for hashCodes that do not differ in lower or upper bits.
  - static java.lang.ref.ReferenceQueue<java.lang.Object> startReclamation()
  - static final void storeNode(CustomConcurrentHashMap.Node[] table, int i, CustomConcurrentHashMap.Node r)
  - static final void storeSegment(CustomConcurrentHashMap.Segment[] segs, int i, CustomConcurrentHashMap.Segment s)
  - CustomConcurrentHashMap valueOf(java.lang.String name)
    
    Returns the enum constant of this type with the specified name.
  - CustomConcurrentHashMap[] values()
    
    Returns an array containing the constants of this enum type, in the order they are declared.
  - public java.util.Collection<V> values()
    
    Returns a java.util.Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. The collection supports element removal, which removes the corresponding mapping from this map, via the Iterator.remove, Collection.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
    The view's iterator is a "weakly consistent" iterator that will never throw java.util.ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
  - private void writeObject(java.io.ObjectOutputStream s)
    
    Saves the state of the instance to a stream (i.e., serializes it).
    serialData:
    the key (Object) and value (Object) for each key-value mapping, followed by a null pair. The key-value mappings are emitted in no particular order.
    
    Parameters:
    s - the stream

| Detail:
Field
Constructor
Method

[Java] Class CustomConcurrentHashMap<K, V>

Nested Class Summary

Field Summary

Constructor Summary

Methods Summary

Inherited Methods Summary

Field Detail

public static final Equivalence<java.lang.Object> EQUALS

public static final Equivalence<java.lang.Object> IDENTITY

private static final java.lang.String INT_STRING

static final int MAX_SEGMENT_CAPACITY

static final int MIN_SEGMENT_CAPACITY

static final int NSEGMENTS

static final int SEGMENT_BITS

static final int SEGMENT_MASK

static final int SEGMENT_SHIFT

private static final java.lang.String SELF_STRING

public static final CustomConcurrentHashMap.Strength SOFT

public static final CustomConcurrentHashMap.Strength STRONG

static final sun.misc.Unsafe UNSAFE

public static final CustomConcurrentHashMap.Strength WEAK

java.util.Set<Map.Entry<K, V>> entrySet

final CustomConcurrentHashMap.NodeFactory factory

final int initialSegmentCapacity

final Equivalence<? super K> keyEquivalence

java.util.Set<K> keySet

static java.lang.ref.ReferenceQueue<java.lang.Object> refQueue

CustomConcurrentHashMap.Segment[] segments

static final long segmentsBase

static final int segmentsShift

private static final long serialVersionUID

static final long tableBase

static final int tableShift

final Equivalence<? super V> valueEquivalence

java.util.Collection<V> values

Constructor Detail

CustomConcurrentHashMap()

Method Detail

java.lang.Object CustomConcurrentHashMap(java.lang.String ks, Equivalence<? super K> keq, java.lang.String vs, Equivalence<? super V> veq, int expectedSize)

public java.lang.Object CustomConcurrentHashMap(CustomConcurrentHashMap.Strength keyStrength, Equivalence<? super K> keyEquivalence, CustomConcurrentHashMap.Strength valueStrength, Equivalence<? super V> valueEquivalence, int expectedSize)

public java.lang.Object CustomConcurrentHashMap()

public final void clear()

public V compute(K key, RemappingFunction<? super K, V> remappingFunction)

public V computeIfAbsent(K key, MappingFunction<? super K, ? extends V> mappingFunction)

public boolean containsKey(java.lang.Object key)

public final boolean containsValue(java.lang.Object value)

final V doPut(K key, V value, boolean onlyIfNull)

public java.util.Set<Map.Entry<K, V>> entrySet()

public boolean equals(java.lang.Object o)

final CustomConcurrentHashMap.Node findNode(java.lang.Object key, int hash, CustomConcurrentHashMap.Segment seg)

public V get(java.lang.Object key)

static java.lang.ref.ReferenceQueue<java.lang.Object> getReclamationQueue()

final CustomConcurrentHashMap.Segment getSegmentForAdd(int hash)

final CustomConcurrentHashMap.Segment getSegmentForTraversal(int hash)

private static sun.misc.Unsafe getUnsafe()

public int hashCode()

public final boolean isEmpty()

final CustomConcurrentHashMap.KeyIterator keyIterator()

public java.util.Set<K> keySet()

public static CustomConcurrentHashMap<java.lang.Integer, java.lang.Integer> newIntKeyIntValueMap(int expectedSize)

public static CustomConcurrentHashMap<java.lang.Integer, ValueType> newIntKeyMap(CustomConcurrentHashMap.Strength valueStrength, Equivalence<? super ValueType> valueEquivalence, int expectedSize)

public static CustomConcurrentHashMap<KeyType, java.lang.Integer> newIntValueMap(CustomConcurrentHashMap.Strength keyStrength, Equivalence<? super KeyType> keyEquivalence, int expectedSize)

public V put(K key, V value)

public void putAll(java.util.Map<? extends K, ? extends V> m)

public V putIfAbsent(K key, V value)

private void readObject(java.io.ObjectInputStream s)

public V remove(java.lang.Object key)

public boolean remove(java.lang.Object key, java.lang.Object value)

final void removeIfReclaimed(CustomConcurrentHashMap.Node r)

public V replace(K key, V value)

public boolean replace(K key, V oldValue, V newValue)

public final int size()

static int spreadHash(int h)

static java.lang.ref.ReferenceQueue<java.lang.Object> startReclamation()

static final void storeNode(CustomConcurrentHashMap.Node[] table, int i, CustomConcurrentHashMap.Node r)

static final void storeSegment(CustomConcurrentHashMap.Segment[] segs, int i, CustomConcurrentHashMap.Segment s)

CustomConcurrentHashMap valueOf(java.lang.String name)

CustomConcurrentHashMap[] values()

public java.util.Collection<V> values()

private void writeObject(java.io.ObjectOutputStream s)