Class CustomConcurrentHashMap<K,V>
- java.lang.Object
-
- java.util.AbstractMap<K,V>
-
- extra166y.CustomConcurrentHashMap<K,V>
-
- Type Parameters:
K
- the type of keys maintained by this mapV
- the type of mapped values
- All Implemented Interfaces:
java.io.Serializable
,java.util.concurrent.ConcurrentMap<K,V>
,java.util.Map<K,V>
public class CustomConcurrentHashMap<K,V> extends java.util.AbstractMap<K,V> implements java.util.concurrent.ConcurrentMap<K,V>, java.io.Serializable
Ajava.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
CustomConcurrentHashMap.Equivalence
-based comparisons controlling membership. - Soft, weak or strong (regular) keys and values.
- User-definable
MappingFunctions
that may be used in methodcomputeIfAbsent(K, extra166y.CustomConcurrentHashMap.MappingFunction<? super K, ? extends V>)
to atomically establish a computed value, along withRemappingFunctions
that can be used in methodcompute(K, extra166y.CustomConcurrentHashMap.RemappingFunction<? super K, V>)
to atomically replace values. - Factory methods returning specialized forms for int keys and/or values, that may be more space-efficient
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);
IdentityHashMap
, and the second a replacement forWeakHashMap
, 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
CustomConcurrentHashMap.KeySet
that provides space-efficient Set views of maps, also supporting methodintern
, 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 ascontainsValue
have weaker guarantees than you might expect even in the absence of other explicitly concurrent operations. For examplecontainsValue(value)
may return true even ifvalue
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 theConcurrentMap
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.
- See Also:
- Serialized Form
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description static interface
CustomConcurrentHashMap.Equivalence<K>
An object performing equality comparisons, along with a hash function consistent with this comparison.static class
CustomConcurrentHashMap.KeySet<K>
A hash-based set with properties identical to those ofCollections.newSetFromMap
applied to aCustomConcurrentHashMap
, but possibly more space-efficient.static interface
CustomConcurrentHashMap.MappingFunction<K,V>
A function computing a mapping from the given key to a value, ornull
if there is no mapping.static interface
CustomConcurrentHashMap.RemappingFunction<K,V>
A function computing a new mapping from the given key and its current value to a new value, ornull
if there is no mappingstatic class
CustomConcurrentHashMap.Strength
The strength of keys and values that may be held by maps.
-
Field Summary
Fields Modifier and Type Field Description static CustomConcurrentHashMap.Equivalence<java.lang.Object>
EQUALS
An Equivalence object performingObject.equals(java.lang.Object)
based comparisons and usingObject.hashCode()
hashingstatic CustomConcurrentHashMap.Equivalence<java.lang.Object>
IDENTITY
An Equivalence object performing identity-based comparisons and usingSystem.identityHashCode(java.lang.Object)
for hashingstatic CustomConcurrentHashMap.Strength
SOFT
The strength of soft referencesstatic CustomConcurrentHashMap.Strength
STRONG
The strength of ordinary referencesstatic CustomConcurrentHashMap.Strength
WEAK
The strength of weak references
-
Constructor Summary
Constructors Constructor Description CustomConcurrentHashMap()
Creates a new CustomConcurrentHashMap with strong keys and values, and equality-based equivalence.CustomConcurrentHashMap(CustomConcurrentHashMap.Strength keyStrength, CustomConcurrentHashMap.Equivalence<? super K> keyEquivalence, CustomConcurrentHashMap.Strength valueStrength, CustomConcurrentHashMap.Equivalence<? super V> valueEquivalence, int expectedSize)
Creates a new CustomConcurrentHashMap with the given parameters
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description void
clear()
Removes all of the mappings from this map.V
compute(K key, CustomConcurrentHashMap.RemappingFunction<? super K,V> remappingFunction)
Updates the mapping for the given key with the result of the given remappingFunction.V
computeIfAbsent(K key, CustomConcurrentHashMap.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.java.util.Set<java.util.Map.Entry<K,V>>
entrySet()
Returns aSet
view of the mappings contained in this map.boolean
equals(java.lang.Object o)
Compares the specified object with this map for equality.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, ornull
if no such mapping existsint
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.java.util.Set<K>
keySet()
Returns aSet
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 valuesstatic <ValueType>
CustomConcurrentHashMap<java.lang.Integer,ValueType>newIntKeyMap(CustomConcurrentHashMap.Strength valueStrength, CustomConcurrentHashMap.Equivalence<? super ValueType> valueEquivalence, int expectedSize)
Returns a new map using Integer keys and the given value parametersstatic <KeyType> CustomConcurrentHashMap<KeyType,java.lang.Integer>
newIntValueMap(CustomConcurrentHashMap.Strength keyStrength, CustomConcurrentHashMap.Equivalence<? super KeyType> keyEquivalence, int expectedSize)
Returns a new map using the given key parameters and Integer valuesV
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)
V
remove(java.lang.Object key)
Removes the mapping for the specified key.boolean
remove(java.lang.Object key, java.lang.Object value)
V
replace(K key, V value)
boolean
replace(K key, V oldValue, V newValue)
int
size()
Returns the number of key-value mappings in this map.java.util.Collection<V>
values()
Returns aCollection
view of the values contained in this map.
-
-
-
Field Detail
-
STRONG
public static final CustomConcurrentHashMap.Strength STRONG
The strength of ordinary references
-
WEAK
public static final CustomConcurrentHashMap.Strength WEAK
The strength of weak references
-
SOFT
public static final CustomConcurrentHashMap.Strength SOFT
The strength of soft references
-
IDENTITY
public static final CustomConcurrentHashMap.Equivalence<java.lang.Object> IDENTITY
An Equivalence object performing identity-based comparisons and usingSystem.identityHashCode(java.lang.Object)
for hashing
-
EQUALS
public static final CustomConcurrentHashMap.Equivalence<java.lang.Object> EQUALS
An Equivalence object performingObject.equals(java.lang.Object)
based comparisons and usingObject.hashCode()
hashing
-
-
Constructor Detail
-
CustomConcurrentHashMap
public CustomConcurrentHashMap(CustomConcurrentHashMap.Strength keyStrength, CustomConcurrentHashMap.Equivalence<? super K> keyEquivalence, CustomConcurrentHashMap.Strength valueStrength, CustomConcurrentHashMap.Equivalence<? super V> valueEquivalence, int expectedSize)
Creates a new CustomConcurrentHashMap with the given parameters- Parameters:
keyStrength
- the strength for keyskeyEquivalence
- the Equivalence to use for keysvalueStrength
- the strength for valuesvalueEquivalence
- the Equivalence to use for valuesexpectedSize
- an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.
-
CustomConcurrentHashMap
public CustomConcurrentHashMap()
Creates a new CustomConcurrentHashMap with strong keys and values, and equality-based equivalence.
-
-
Method Detail
-
newIntKeyMap
public static <ValueType> CustomConcurrentHashMap<java.lang.Integer,ValueType> newIntKeyMap(CustomConcurrentHashMap.Strength valueStrength, CustomConcurrentHashMap.Equivalence<? super ValueType> valueEquivalence, int expectedSize)
Returns a new map using Integer keys and the given value parameters- Parameters:
valueStrength
- the strength for valuesvalueEquivalence
- the Equivalence to use for valuesexpectedSize
- an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.- Returns:
- the map
-
newIntValueMap
public static <KeyType> CustomConcurrentHashMap<KeyType,java.lang.Integer> newIntValueMap(CustomConcurrentHashMap.Strength keyStrength, CustomConcurrentHashMap.Equivalence<? super KeyType> keyEquivalence, int expectedSize)
Returns a new map using the given key parameters and Integer values- Parameters:
keyStrength
- the strength for keyskeyEquivalence
- the Equivalence to use for keysexpectedSize
- an estimate of the number of elements that will be held in the map. If no estimate is known, zero is an acceptable value.- Returns:
- the map
-
newIntKeyIntValueMap
public static CustomConcurrentHashMap<java.lang.Integer,java.lang.Integer> newIntKeyIntValueMap(int expectedSize)
Returns a new map using Integer keys and values- 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.- Returns:
- the map
-
containsKey
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.
-
get
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, ornull
if no such mapping exists
-
put
public V put(K key, V value)
Maps the specified key to the specified value in this map.- Specified by:
put
in interfacejava.util.Map<K,V>
- Overrides:
put
in classjava.util.AbstractMap<K,V>
- Parameters:
key
- key with which the specified value is to be associatedvalue
- value to be associated with the specified key- Returns:
- the previous value associated with key, or null if there was no mapping for key
- Throws:
java.lang.NullPointerException
- if the specified key or value is null
-
putIfAbsent
public V putIfAbsent(K key, V value)
- Specified by:
putIfAbsent
in interfacejava.util.concurrent.ConcurrentMap<K,V>
- Specified by:
putIfAbsent
in interfacejava.util.Map<K,V>
- Returns:
- the previous value associated with the specified key, or null if there was no mapping for the key
- Throws:
java.lang.NullPointerException
- if the specified key or value is null
-
putAll
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.
-
replace
public boolean replace(K key, V oldValue, V newValue)
- Specified by:
replace
in interfacejava.util.concurrent.ConcurrentMap<K,V>
- Specified by:
replace
in interfacejava.util.Map<K,V>
- Returns:
- the previous value associated with the specified key, or null if there was no mapping for the key
- Throws:
java.lang.NullPointerException
- if the specified key or value is null
-
remove
public V remove(java.lang.Object key)
Removes the mapping for the specified key.- Specified by:
remove
in interfacejava.util.Map<K,V>
- Overrides:
remove
in classjava.util.AbstractMap<K,V>
- Parameters:
key
- the key to remove- Returns:
- the previous value associated with key, or null if there was no mapping for key
- Throws:
java.lang.NullPointerException
- if the specified key is null
-
remove
public boolean remove(java.lang.Object key, java.lang.Object value)
-
isEmpty
public final boolean isEmpty()
Returns true if this map contains no key-value mappings.
-
size
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.
-
containsValue
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.- Specified by:
containsValue
in interfacejava.util.Map<K,V>
- Overrides:
containsValue
in classjava.util.AbstractMap<K,V>
- Parameters:
value
- value whose presence in this map is to be tested- Returns:
- true if this map maps one or more keys to the specified value
- Throws:
java.lang.NullPointerException
- if the specified value is null
-
clear
public final void clear()
Removes all of the mappings from this map.
-
computeIfAbsent
public V computeIfAbsent(K key, CustomConcurrentHashMap.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 toif (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.- Parameters:
key
- key with which the specified value is to be associatedmappingFunction
- the function to compute a value- Returns:
- the current (existing or computed) value associated with the specified key, or null if the computation returned null.
- Throws:
java.lang.NullPointerException
- if the specified key or mappingFunction is null,java.lang.RuntimeException
- or Error if the mappingFunction does so, in which case the mapping is left unestablished.
-
compute
public V compute(K key, CustomConcurrentHashMap.RemappingFunction<? super K,V> remappingFunction)
Updates the mapping for the given key with the result of the given remappingFunction. This is equivalent tovalue = 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; }});
- Parameters:
key
- key with which the specified value is to be associatedremappingFunction
- the function to compute a value- Returns:
- the updated value or null if the computation returned null
- Throws:
java.lang.NullPointerException
- if the specified key or remappingFunction is null,java.lang.RuntimeException
- or Error if the remappingFunction does so, in which case the mapping is left in its previous state
-
keySet
public java.util.Set<K> keySet()
Returns aSet
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
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.
-
values
public java.util.Collection<V> values()
Returns aCollection
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
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.
-
entrySet
public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
Returns aSet
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
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.
-
equals
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.
-
hashCode
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.
-
-