|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectcom.atlassian.util.concurrent.CopyOnWriteMap<K,V>
K
- the key typeV
- the value type@ThreadSafe public abstract class CopyOnWriteMap<K,V>
A thread-safe variant of Map
in which all mutative operations (the
"destructive" operations described by Map
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 an abstract copy(Map)
method. The
method is responsible for the underlying Map implementation (for instance a
HashMap
, TreeMap
, LinkedHashMap
etc.) and therefore
the semantics of what this map will cope with as far as null keys and values,
iteration ordering etc. See the note below about suitable candidates for
underlying Map implementations
There are supplied implementations for the common Collections Map
implementations via the CopyOnWriteMaps
static factory methods.
Collection views of the keys, values and entries are modifiable and will cause a copy.
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. For instance some implementations such as
WeakHashMap
and LinkedHashMap
with access ordering are
actually structurally modified by the get(Object)
method and are
therefore not suitable candidates as delegates for this class.
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 | |
---|---|
CopyOnWriteMap()
Create a new empty CopyOnWriteMap . |
|
CopyOnWriteMap(java.util.Map<? extends K,? extends V> map)
Create a new CopyOnWriteMap with the supplied Map to
initialize the values. |
Method Summary | ||
---|---|---|
void |
clear()
|
|
boolean |
containsKey(java.lang.Object key)
|
|
boolean |
containsValue(java.lang.Object value)
|
|
protected M |
copy()
|
|
abstract
|
copy(N map)
|
|
java.util.Set<java.util.Map.Entry<K,V>> |
entrySet()
|
|
boolean |
equals(java.lang.Object o)
|
|
V |
get(java.lang.Object key)
|
|
protected M |
getDelegate()
|
|
int |
hashCode()
|
|
boolean |
isEmpty()
|
|
java.util.Set<K> |
keySet()
|
|
V |
put(K key,
V value)
|
|
void |
putAll(java.util.Map<? extends K,? extends V> t)
|
|
V |
remove(java.lang.Object key)
|
|
protected void |
removeAll(java.util.Collection<K> keys)
|
|
protected void |
set(M map)
|
|
int |
size()
|
|
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 |
---|
public CopyOnWriteMap(java.util.Map<? extends K,? extends V> map)
CopyOnWriteMap
with the supplied Map
to
initialize the values.
map
- the initial map to initialize withfactory
- the copy functionpublic CopyOnWriteMap()
CopyOnWriteMap
.
factory
- the copy functionMethod Detail |
---|
public abstract <N extends java.util.Map<? extends K,? extends V>> java.util.Map<K,V> copy(N map)
public final void clear()
clear
in interface java.util.Map<K,V>
public final V remove(java.lang.Object key)
remove
in interface java.util.Map<K,V>
public final V put(K key, V value)
put
in interface java.util.Map<K,V>
public final void putAll(java.util.Map<? extends K,? extends V> t)
putAll
in interface java.util.Map<K,V>
protected void removeAll(java.util.Collection<K> keys)
protected M copy()
protected void set(M map)
public final java.util.Set<java.util.Map.Entry<K,V>> entrySet()
entrySet
in interface java.util.Map<K,V>
public final java.util.Set<K> keySet()
keySet
in interface java.util.Map<K,V>
public final java.util.Collection<V> values()
values
in interface java.util.Map<K,V>
public final boolean containsKey(java.lang.Object key)
containsKey
in interface java.util.Map<K,V>
public final boolean containsValue(java.lang.Object value)
containsValue
in interface java.util.Map<K,V>
public final V get(java.lang.Object key)
get
in interface java.util.Map<K,V>
public final boolean isEmpty()
isEmpty
in interface java.util.Map<K,V>
public final int size()
size
in interface java.util.Map<K,V>
public final boolean equals(java.lang.Object o)
equals
in interface java.util.Map<K,V>
equals
in class java.lang.Object
public final int hashCode()
hashCode
in interface java.util.Map<K,V>
hashCode
in class java.lang.Object
protected final M getDelegate()
public java.lang.String toString()
toString
in class java.lang.Object
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |