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

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

All Implemented Interfaces:

java.io.Serializable, java.util.Map<K,V>

@ThreadSafe
public abstract class CopyOnWriteMap<K,V>
extends java.lang.Object
implements java.util.Map<K,V>, java.io.Serializable

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 a supplied CopyOnWriteMap.CopyFunction object. The Factory is responsible for the underlying Map implementation (for instance a HashMap, TreeMap, ListOrderedMap etc.) and therefore the semantics of what this map will cope with as far as null keys and values, iteration ordering etc.

There are supplied Functions for the common Collections Map implementations.

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.

See Also:

Serialized Form

Nested Class Summary

protected static class	AbstractCopyOnWriteMap.CollectionView<E>
static interface	CopyOnWriteMap.CopyFunction<M extends java.util.Map<?,?>>

Nested classes/interfaces inherited from interface java.util.Map

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

Constructor Summary

CopyOnWriteMap()
Create a new empty CopyOnWriteMap with the CopyOnWriteMap.CopyFunction for creating our actual delegate instances.

CopyOnWriteMap(java.util.Map<? extends K,? extends V> map)
Create a new CopyOnWriteMap with the supplied Map to initialize the values and the CopyOnWriteMap.CopyFunction for creating our actual delegate instances.

Method Summary

void	clear()
boolean	containsKey(java.lang.Object key)
boolean	containsValue(java.lang.Object value)
protected M	copy()
abstract <N extends java.util.Map<? extends K,? extends V>> java.util.Map<K,V>	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()
static <K,V> CopyOnWriteMap<K,V>	newHashMap() Creates a new CopyOnWriteMap with an underlying HashMap.
static <K,V> CopyOnWriteMap<K,V>	newHashMap(java.util.Map<? extends K,? extends V> map) Creates a new CopyOnWriteMap with an underlying HashMap using the supplied map as the initial values.
static <K,V> CopyOnWriteMap<K,V>	newLinkedMap() Creates a new CopyOnWriteMap with an underlying LinkedHashMap.
static <K,V> CopyOnWriteMap<K,V>	newLinkedMap(java.util.Map<? extends K,? extends V> map) Creates a new CopyOnWriteMap with an underlying LinkedHashMap using the supplied map as the initial values.
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

CopyOnWriteMap

public CopyOnWriteMap(java.util.Map<? extends K,? extends V> map)

Create a new CopyOnWriteMap with the supplied Map to initialize the values and the CopyOnWriteMap.CopyFunction for creating our actual delegate instances.

Parameters:

map - the initial map to initialize with

factory - the copy function

CopyOnWriteMap

public CopyOnWriteMap()

Create a new empty CopyOnWriteMap with the CopyOnWriteMap.CopyFunction for creating our actual delegate instances.

Parameters:

factory - the copy function

Method Detail

newHashMap

public static <K,V> CopyOnWriteMap<K,V> newHashMap()

Creates a new CopyOnWriteMap with an underlying HashMap.

newHashMap

public static <K,V> CopyOnWriteMap<K,V> newHashMap(java.util.Map<? extends K,? extends V> map)

Creates a new CopyOnWriteMap with an underlying HashMap using the supplied map as the initial values.

newLinkedMap

public static <K,V> CopyOnWriteMap<K,V> newLinkedMap()

Creates a new CopyOnWriteMap with an underlying LinkedHashMap. Iterators for this map will be return elements in insertion order.

newLinkedMap

public static <K,V> CopyOnWriteMap<K,V> newLinkedMap(java.util.Map<? extends K,? extends V> map)

Creates a new CopyOnWriteMap with an underlying LinkedHashMap using the supplied map as the initial values. Iterators for this map will be return elements in insertion order.

copy

public abstract <N extends java.util.Map<? extends K,? extends V>> java.util.Map<K,V> copy(N map)

clear

public final void clear()

Specified by:

clear in interface java.util.Map<K,V>

remove

public final V remove(java.lang.Object key)

Specified by:

remove in interface java.util.Map<K,V>

put

public final V put(K key,
                   V value)

Specified by:

put in interface java.util.Map<K,V>

putAll

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

Specified by:

putAll in interface java.util.Map<K,V>

removeAll

protected void removeAll(java.util.Collection<K> keys)

copy

protected M copy()

set

protected void set(M map)

entrySet

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

Specified by:

entrySet in interface java.util.Map<K,V>

keySet

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

Specified by:

keySet in interface java.util.Map<K,V>

values

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

Specified by:

values in interface java.util.Map<K,V>

containsKey

public final boolean containsKey(java.lang.Object key)

Specified by:

containsKey in interface java.util.Map<K,V>

containsValue

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

Specified by:

containsValue in interface java.util.Map<K,V>

get

public final V get(java.lang.Object key)

Specified by:

get in interface java.util.Map<K,V>

isEmpty

public final boolean isEmpty()

Specified by:

isEmpty in interface java.util.Map<K,V>

size

public final int size()

Specified by:

size in interface java.util.Map<K,V>

equals

public final boolean equals(java.lang.Object o)

Specified by:

equals in interface java.util.Map<K,V>

Overrides:

equals in class java.lang.Object

hashCode

public final int hashCode()

Specified by:

hashCode in interface java.util.Map<K,V>

Overrides:

hashCode in class java.lang.Object

getDelegate

protected final M getDelegate()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object