CopyOnWriteSortedMap (Atlassian Concurrency Utilities 0.0.9 API)

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.atlassian.util.concurrent
Class CopyOnWriteSortedMap<K,V>

java.lang.Object
  com.atlassian.util.concurrent.CopyOnWriteSortedMap<K,V>


Type Parameters:: K - the key type; V - the value type

All Implemented Interfaces:: java.io.Serializable, java.util.concurrent.ConcurrentMap<K,V>, java.util.Map<K,V>, java.util.SortedMap<K,V>

@ThreadSafe public abstract class CopyOnWriteSortedMap<K,V>
extends java.lang.Object
implements java.util.SortedMap<K,V>
extends java.lang.Object
implements java.util.SortedMap<K,V>

/** A thread-safe variant of SortedMap in which all mutative operations (the "destructive" operations described by SortedMap put, remove and so on) are implemented by making a fresh copy of the underlying map.

This is ordinarily too costly, but may be more efficient than alternatives when traversal operations vastly out-number mutations, and is useful when you cannot or don't want to synchronize traversals, yet need to preclude interference among concurrent threads. The "snapshot" style iterators on the collections returned by entrySet(), keySet() and values() use a reference to the internal map at the point that the iterator was created. This map never changes during the lifetime of the iterator, so interference is impossible and the iterator is guaranteed not to throw ConcurrentModificationException. The iterators will not reflect additions, removals, or changes to the list since the iterator was created. Removing elements via these iterators is not supported. The mutable operations on these collections (remove, retain etc.) are supported but as with the Map interface, add and addAll are not and throw UnsupportedOperationException.

The actual copy is performed by the abstract copy(Map) method. This implementation of this method is responsible for the underlying SortedMap implementation (for instance a TreeMap) and therefore the semantics of what this map will cope with as far as null keys and values, iteration ordering etc.

Views of the keys, values and entries are modifiable and will cause a copy. Views taken using subMap(Object, Object), headMap(Object) and tailMap(Object) are unmodifiable.

Please note that the thread-safety guarantees are limited to the thread-safety of the non-mutative (non-destructive) operations of the underlying map implementation.

Author:: Jed Wesley-Smith
See Also:: Serialized Form

Nested Class Summary
`protected static class`	`AbstractCopyOnWriteMap.CollectionView<E>`

Nested classes/interfaces inherited from interface java.util.Map
`java.util.Map.Entry<K,V>`

Constructor Summary
`protected`	`CopyOnWriteSortedMap()` Create a new empty `CopyOnWriteMap`.
`protected`	`CopyOnWriteSortedMap(java.util.Map<? extends K,? extends V> map)` Create a new `CopyOnWriteMap` with the supplied `Map` to initialize the values.

Method Summary

void clear()

java.util.Comparator<? super K> comparator()

boolean containsKey(java.lang.Object key)

boolean containsValue(java.lang.Object value)

protected M copy()

protected abstract 



<N extends java.util.Map<? extends K,? extends V>> 


java.util.SortedMap<K,V>

copy(N map)
Copy function, implemented by sub-classes.

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

boolean equals(java.lang.Object o)

K firstKey()

V get(java.lang.Object key)

protected M getDelegate()

int hashCode()

java.util.SortedMap<K,V> headMap(K toKey)

boolean isEmpty()

java.util.Set<K> keySet()

K lastKey()

static



<K,V> CopyOnWriteSortedMap<K,V>

newTreeMap()
Create a new CopyOnWriteSortedMap where the underlying map instances are TreeMap and the sort uses the key's natural order.

static



<K,V> CopyOnWriteSortedMap<K,V>

newTreeMap(java.util.Comparator<? super K> comparator)
Create a new CopyOnWriteSortedMap where the underlying map instances are TreeMap.

static



<K,V> CopyOnWriteSortedMap<K,V>

newTreeMap(java.util.Map<? extends K,? extends V> map)
Create a new CopyOnWriteSortedMap where the underlying map instances are TreeMap, the sort uses the key's natural order and the initial values are supplied.

static



<K,V> CopyOnWriteSortedMap<K,V>

newTreeMap(java.util.Map<? extends K,? extends V> map,
           java.util.Comparator<? super K> comparator)

Create a new CopyOnWriteSortedMap where the underlying map instances are TreeMap, the sort uses the key's natural order and the initial values are supplied.

V put(K key, V value)

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

V putIfAbsent(K key, V value)

V remove(java.lang.Object 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)

protected void set(M map)

int size()

java.util.SortedMap<K,V> subMap(K fromKey, K toKey)

java.util.SortedMap<K,V> tailMap(K fromKey)

java.lang.String toString()

java.util.Collection<V> values()

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface java.util.Map
`clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, values`

Constructor Detail