java.util.concurrent

Class ConcurrentSkipListMap<K,V>

Implemented Interfaces:
Cloneable, ConcurrentMap<K,V>, ConcurrentNavigableMap<K,V>, Map<K,V>, NavigableMap<K,V>, Serializable, SortedMap<K,V>

public class ConcurrentSkipListMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentNavigableMap<K,V>, Cloneable, Serializable

A scalable concurrent ConcurrentNavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.

This class implements a concurrent variant of SkipLists providing expected average log(n) time cost for the containsKey, get, put and remove operations and their variants. Insertion, removal, update, and access operations safely execute concurrently by multiple threads. Iterators are weakly consistent, returning elements reflecting the state of the map at some point at or since the creation of the iterator. They do not throw ConcurrentModificationException, and may proceed concurrently with other operations. Ascending key ordered views and their iterators are faster than descending ones.

All Map.Entry pairs returned by methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method. (Note however that it is possible to change mappings in the associated map using put, putIfAbsent, or replace, depending on exactly which effect you need.)

Beware that, unlike in most collections, the size method is not a constant-time operation. Because of the asynchronous nature of these maps, determining the current number of elements requires a traversal of the elements. Additionally, the bulk operations putAll, equals, and clear are not guaranteed to be performed atomically. For example, an iterator operating concurrently with a putAll operation might view only some of the added elements.

This class and its views and iterators implement all of the optional methods of the Map and Iterator interfaces. Like most other concurrent collections, this class does not permit the use of null keys or values because some null return values cannot be reliably distinguished from the absence of elements.

This class is a member of the ../../../../technotes/guides/collections/index.html"> Java Collections Framework.

Since:
1.6
See Also:
Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap<K,V>

AbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry

Constructor Summary

ConcurrentSkipListMap()
Constructs a new, empty map, sorted according to the natural ordering of the keys.
ConcurrentSkipListMap(K> comparator)
Constructs a new, empty map, sorted according to the specified comparator.
ConcurrentSkipListMap(SortedMap m)
Constructs a new map containing the same mappings and using the same ordering as the specified sorted map.
ConcurrentSkipListMap(extends K, V> m)
Constructs a new map containing the same mappings as the given map, sorted according to the natural ordering of the keys.

Method Summary

java.util.Map.Entry
ceilingEntry(K key)
Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such entry.
K
ceilingKey(K key)
void
clear()
Removes all of the mappings from this map.
ConcurrentSkipListMap
clone()
Returns a shallow copy of this ConcurrentSkipListMap instance.
boolean
containsKey(Object key)
Returns true if this map contains a mapping for the specified key.
boolean
containsValue(Object value)
Returns true if this map maps one or more keys to the specified value.
NavigableSet
descendingKeySet()
Returns a reverse order NavigableSet view of the keys contained in this map.
ConcurrentNavigableMap
descendingMap()
Returns a reverse order view of the mappings contained in this map.
Set>
entrySet()
Returns a Set view of the mappings contained in this map.
boolean
equals(Object o)
Compares the specified object with this map for equality.
java.util.Map.Entry
firstEntry()
Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
K
firstKey()
java.util.Map.Entry
floorEntry(K key)
Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
K
floorKey(K key)
V
get(Object key)
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
ConcurrentNavigableMap
headMap(K toKey)
ConcurrentNavigableMap
headMap(K toKey, boolean inclusive)
java.util.Map.Entry
higherEntry(K key)
Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
K
higherKey(K key)
boolean
isEmpty()
Returns true if this map contains no key-value mappings.
NavigableSet
keySet()
Returns a NavigableSet view of the keys contained in this map.
java.util.Map.Entry
lastEntry()
Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
K
lastKey()
java.util.Map.Entry
lowerEntry(K key)
Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
K
lowerKey(K key)
NavigableSet
navigableKeySet()
Returns a NavigableSet view of the keys contained in this map.
java.util.Map.Entry
pollFirstEntry()
Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.
java.util.Map.Entry
pollLastEntry()
Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
V
put(K key, V value)
Associates the specified value with the specified key in this map.
V
putIfAbsent(K key, V value)
V
remove(Object key)
Removes the mapping for the specified key from this map if present.
boolean
remove(Object key, 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.
ConcurrentNavigableMap
subMap(K fromKey, K toKey)
ConcurrentNavigableMap
subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
Comparator
super K> comparator()
Returns the comparator used in sorting this map, or null if it is the keys' natural ordering.
ConcurrentNavigableMap
tailMap(K fromKey)
ConcurrentNavigableMap
tailMap(K fromKey, boolean inclusive)
Collection
values()
Returns a Collection view of the values contained in this map.

Methods inherited from class java.util.AbstractMap<K,V>

V>> entrySet, clear, clone, containsKey, containsValue, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, toString, values

Methods inherited from class java.lang.Object

clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

ConcurrentSkipListMap

public ConcurrentSkipListMap()
Constructs a new, empty map, sorted according to the natural ordering of the keys.

ConcurrentSkipListMap

public ConcurrentSkipListMap(K> comparator)
Constructs a new, empty map, sorted according to the specified comparator.
Parameters:
comparator - the comparator that will be used to order this map. If null, the natural ordering of the keys will be used.

ConcurrentSkipListMap

public ConcurrentSkipListMap(SortedMap m)
Constructs a new map containing the same mappings and using the same ordering as the specified sorted map.
Parameters:
m - the sorted map whose mappings are to be placed in this map, and whose comparator is to be used to sort this map
Throws:
NullPointerException - if the specified sorted map or any of its keys or values are null

ConcurrentSkipListMap

public ConcurrentSkipListMap(extends K,
                             V> m)
Constructs a new map containing the same mappings as the given map, sorted according to the natural ordering of the keys.
Parameters:
m - the map whose mappings are to be placed in this map
Throws:
ClassCastException - if the keys in m are not Comparable, or are not mutually comparable
NullPointerException - if the specified map or any of its keys or values are null

Method Details

ceilingEntry

public java.util.Map.Entry ceilingEntry(K key)
Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such entry. The returned entry does not support the Entry.setValue method.
Specified by:
ceilingEntry in interface NavigableMap<K,V>
Throws:
ClassCastException -
NullPointerException - if the specified key is null

ceilingKey

public K ceilingKey(K key)
Specified by:
ceilingKey in interface NavigableMap<K,V>
Throws:
ClassCastException -
NullPointerException - if the specified key is null

clear

public void clear()
Removes all of the mappings from this map.
Specified by:
clear in interface Map<K,V>
Overrides:
clear in interface AbstractMap<K,V>

clone

public ConcurrentSkipListMap clone()
Returns a shallow copy of this ConcurrentSkipListMap instance. (The keys and values themselves are not cloned.)
Overrides:
clone in interface AbstractMap<K,V>
Returns:
a shallow copy of this map

containsKey

public boolean containsKey(Object key)
Returns true if this map contains a mapping for the specified key.
Specified by:
containsKey in interface Map<K,V>
Overrides:
containsKey in interface AbstractMap<K,V>
Parameters:
key - key whose presence in this map is to be tested
Returns:
true if this map contains a mapping for the specified key
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key is null

containsValue

public boolean containsValue(Object value)
Returns true if this map maps one or more keys to the specified value. This operation requires time linear in the map size.
Specified by:
containsValue in interface Map<K,V>
Overrides:
containsValue in interface AbstractMap<K,V>
Parameters:
value - value whose presence in this map is to be tested
Returns:
true if a mapping to value exists; false otherwise
Throws:
NullPointerException - if the specified value is null

descendingKeySet

public NavigableSet descendingKeySet()
Returns a reverse order NavigableSet view of the keys contained in this map. The set's iterator returns the keys in descending order. 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.

Specified by:
descendingKeySet in interface ConcurrentNavigableMap<K,V>
descendingKeySet in interface NavigableMap<K,V>
Returns:
a reverse order navigable set view of the keys in this map

descendingMap

public ConcurrentNavigableMap descendingMap()
Returns a reverse order view of the mappings contained in this map. The descending map is backed by this map, so changes to the map are reflected in the descending map, and vice-versa.

The returned map has an ordering equivalent to Collections.reverseOrder(comparator()). The expression m.descendingMap().descendingMap() returns a view of m essentially equivalent to m.

Specified by:
descendingMap in interface ConcurrentNavigableMap<K,V>
descendingMap in interface NavigableMap<K,V>
Returns:
a reverse order view of this map

entrySet

public Set> entrySet()
Returns a Set view of the mappings contained in this map. The set's iterator returns the entries in ascending key order. 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.

The Map.Entry elements returned by iterator.next() do not support the setValue operation.

Returns:
a set view of the mappings contained in this map, sorted in ascending key order

equals

public boolean equals(Object o)
Compares the specified object with this map for equality. Returns true if the given object is also a map and the two maps represent the same mappings. More formally, two maps m1 and m2 represent the same mappings if m1.entrySet().equals(m2.entrySet()). This operation may return misleading results if either map is concurrently modified during execution of this method.
Specified by:
equals in interface Map<K,V>
Overrides:
equals in interface AbstractMap<K,V>
Parameters:
o - object to be compared for equality with this map
Returns:
true if the specified object is equal to this map

firstEntry

public java.util.Map.Entry firstEntry()
Returns a key-value mapping associated with the least key in this map, or null if the map is empty. The returned entry does not support the Entry.setValue method.
Specified by:
firstEntry in interface NavigableMap<K,V>

firstKey

public K firstKey()
Specified by:
firstKey in interface SortedMap<K,V>

floorEntry

public java.util.Map.Entry floorEntry(K key)
Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key. The returned entry does not support the Entry.setValue method.
Specified by:
floorEntry in interface NavigableMap<K,V>
Parameters:
key - the key
Throws:
ClassCastException -
NullPointerException - if the specified key is null

floorKey

public K floorKey(K key)
Specified by:
floorKey in interface NavigableMap<K,V>
Parameters:
key - the key
Throws:
ClassCastException -
NullPointerException - if the specified key is null

get

public V get(Object key)
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

More formally, if this map contains a mapping from a key k to a value v such that key compares equal to k according to the map's ordering, then this method returns v; otherwise it returns null. (There can be at most one such mapping.)

Specified by:
get in interface Map<K,V>
Overrides:
get in interface AbstractMap<K,V>
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key is null

headMap

public ConcurrentNavigableMap headMap(K toKey)
Specified by:
headMap in interface ConcurrentNavigableMap<K,V>
headMap in interface NavigableMap<K,V>

headMap

public ConcurrentNavigableMap headMap(K toKey,
                                           boolean inclusive)
Specified by:
headMap in interface ConcurrentNavigableMap<K,V>
headMap in interface NavigableMap<K,V>

higherEntry

public java.util.Map.Entry higherEntry(K key)
Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key. The returned entry does not support the Entry.setValue method.
Specified by:
higherEntry in interface NavigableMap<K,V>
Parameters:
key - the key
Throws:
ClassCastException -
NullPointerException - if the specified key is null

higherKey

public K higherKey(K key)
Specified by:
higherKey in interface NavigableMap<K,V>
Parameters:
key - the key
Throws:
ClassCastException -
NullPointerException - if the specified key is null

isEmpty

public boolean isEmpty()
Returns true if this map contains no key-value mappings.
Specified by:
isEmpty in interface Map<K,V>
Overrides:
isEmpty in interface AbstractMap<K,V>
Returns:
true if this map contains no key-value mappings

keySet

public NavigableSet keySet()
Returns a NavigableSet view of the keys contained in this map. The set's iterator returns the keys in ascending order. 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.

This method is equivalent to method navigableKeySet.

Specified by:
keySet in interface ConcurrentNavigableMap<K,V>
keySet in interface Map<K,V>
Overrides:
keySet in interface AbstractMap<K,V>
Returns:
a navigable set view of the keys in this map

lastEntry

public java.util.Map.Entry lastEntry()
Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty. The returned entry does not support the Entry.setValue method.
Specified by:
lastEntry in interface NavigableMap<K,V>

lastKey

public K lastKey()
Specified by:
lastKey in interface SortedMap<K,V>

lowerEntry

public java.util.Map.Entry lowerEntry(K key)
Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key. The returned entry does not support the Entry.setValue method.
Specified by:
lowerEntry in interface NavigableMap<K,V>
Throws:
ClassCastException -
NullPointerException - if the specified key is null

lowerKey

public K lowerKey(K key)
Specified by:
lowerKey in interface NavigableMap<K,V>
Throws:
ClassCastException -
NullPointerException - if the specified key is null

navigableKeySet

public NavigableSet navigableKeySet()
Returns a NavigableSet view of the keys contained in this map. The set's iterator returns the keys in ascending order. 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.

Specified by:
navigableKeySet in interface ConcurrentNavigableMap<K,V>
navigableKeySet in interface NavigableMap<K,V>
Returns:
a navigable set view of the keys in this map

pollFirstEntry

public java.util.Map.Entry pollFirstEntry()
Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty. The returned entry does not support the Entry.setValue method.
Specified by:
pollFirstEntry in interface NavigableMap<K,V>

pollLastEntry

public java.util.Map.Entry pollLastEntry()
Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty. The returned entry does not support the Entry.setValue method.
Specified by:
pollLastEntry in interface NavigableMap<K,V>

put

public V put(K key,
             V value)
Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.
Specified by:
put in interface Map<K,V>
Overrides:
put in interface AbstractMap<K,V>
Parameters:
key - key with which the specified value is to be associated
value - value to be associated with the specified key
Returns:
the previous value associated with the specified key, or null if there was no mapping for the key
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key or value is null

putIfAbsent

public V putIfAbsent(K key,
                     V value)
Specified by:
putIfAbsent in interface ConcurrentMap<K,V>
Returns:
the previous value associated with the specified key, or null if there was no mapping for the key
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key or value is null

remove

public V remove(Object key)
Removes the mapping for the specified key from this map if present.
Specified by:
remove in interface Map<K,V>
Overrides:
remove in interface AbstractMap<K,V>
Parameters:
key - key for which mapping should be removed
Returns:
the previous value associated with the specified key, or null if there was no mapping for the key
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key is null

remove

public boolean remove(Object key,
                      Object value)
Specified by:
remove in interface ConcurrentMap<K,V>
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key is null

replace

public V replace(K key,
                 V value)
Specified by:
replace in interface ConcurrentMap<K,V>
Returns:
the previous value associated with the specified key, or null if there was no mapping for the key
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if the specified key or value is null

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)
Specified by:
replace in interface ConcurrentMap<K,V>
Throws:
ClassCastException - if the specified key cannot be compared with the keys currently in the map
NullPointerException - if any of the arguments are null

size

public int size()
Returns the number of key-value mappings in this map. If this map contains more than Integer.MAX_VALUE elements, it returns Integer.MAX_VALUE.

Beware that, unlike in most collections, this method is NOT a constant-time operation. Because of the asynchronous nature of these maps, determining the current number of elements requires traversing them all to count them. Additionally, it is possible for the size to change during execution of this method, in which case the returned result will be inaccurate. Thus, this method is typically not very useful in concurrent applications.

Specified by:
size in interface Map<K,V>
Overrides:
size in interface AbstractMap<K,V>
Returns:
the number of elements in this map

subMap

public ConcurrentNavigableMap subMap(K fromKey,
                                          K toKey)
Specified by:
subMap in interface ConcurrentNavigableMap<K,V>
subMap in interface NavigableMap<K,V>
Throws:
ClassCastException -
NullPointerException - if fromKey or toKey is null
IllegalArgumentException -

subMap

public ConcurrentNavigableMap subMap(K fromKey,
                                          boolean fromInclusive,
                                          K toKey,
                                          boolean toInclusive)
Specified by:
subMap in interface ConcurrentNavigableMap<K,V>
subMap in interface NavigableMap<K,V>
Throws:
ClassCastException -
NullPointerException - if fromKey or toKey is null
IllegalArgumentException -

super K> comparator

public Comparatorsuper K> comparator()
Returns the comparator used in sorting this map, or null if it is the keys' natural ordering.
Specified by:
super K> comparator in interface SortedMap<K,V>
Returns:
the sorting comparator

tailMap

public ConcurrentNavigableMap tailMap(K fromKey)
Specified by:
tailMap in interface ConcurrentNavigableMap<K,V>
tailMap in interface NavigableMap<K,V>

tailMap

public ConcurrentNavigableMap tailMap(K fromKey,
                                           boolean inclusive)
Specified by:
tailMap in interface ConcurrentNavigableMap<K,V>
tailMap in interface NavigableMap<K,V>

values

public Collection values()
Returns a Collection view of the values contained in this map. The collection's iterator returns the values in ascending order of the corresponding keys. 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 the 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.

Specified by:
values in interface Map<K,V>
Overrides:
values in interface AbstractMap<K,V>