org.jboss.marshalling.reflect

Class UnlockedHashMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

org.jboss.marshalling.reflect.UnlockedHashMap<K,V>

Type Parameters:

K - the key type

V - the value type

All Implemented Interfaces:

java.util.concurrent.ConcurrentMap<K,V>, java.util.Map<K,V>

final class UnlockedHashMap<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.concurrent.ConcurrentMap<K,V>

Lock-free concurrent hash map.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
(package private) class	UnlockedHashMap.BranchIterator
(package private) class	UnlockedHashMap.EntryIterator
(package private) class	UnlockedHashMap.EntrySet
(package private) static class	UnlockedHashMap.Item<K,V>
(package private) class	UnlockedHashMap.KeyIterator
(package private) class	UnlockedHashMap.KeySet
(package private) class	UnlockedHashMap.RowIterator
(package private) static class	UnlockedHashMap.Table<K,V>
(package private) class	UnlockedHashMap.TableIterator
(package private) class	UnlockedHashMap.ValueIterator
(package private) class	UnlockedHashMap.Values

Nested classes/interfaces inherited from class java.util.AbstractMap

java.util.AbstractMap.SimpleEntry<K,V>, java.util.AbstractMap.SimpleImmutableEntry<K,V>

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

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

Field Summary

Fields

Modifier and Type	Field and Description
private static int	DEFAULT_INITIAL_CAPACITY
private static float	DEFAULT_LOAD_FACTOR
private java.util.Set<java.util.Map.Entry<K,V>>	entrySet
private int	initialCapacity
private java.util.Set<K>	keySet
private float	loadFactor
private static int	MAXIMUM_CAPACITY
private static java.lang.Object	NONEXISTENT A non-existent table entry (as opposed to a null value).
private static UnlockedHashMap.Item<?,?>[]	RESIZED A row which has been resized into the new view.
private static java.util.concurrent.atomic.AtomicIntegerFieldUpdater<UnlockedHashMap.Table>	sizeUpdater
private UnlockedHashMap.Table<K,V>	table
private static java.util.concurrent.atomic.AtomicReferenceFieldUpdater<UnlockedHashMap,UnlockedHashMap.Table>	tableUpdater
private java.util.Collection<V>	values
private static java.util.concurrent.atomic.AtomicReferenceFieldUpdater<UnlockedHashMap.Item,java.lang.Object>	valueUpdater

Constructor Summary

Constructors

Constructor and Description
UnlockedHashMap() Construct a new instance.
UnlockedHashMap(float loadFactor) Construct a new instance.
UnlockedHashMap(int initialCapacity) Construct a new instance.
UnlockedHashMap(int initialCapacity, float loadFactor) Construct a new instance.

Method Summary

Modifier and Type	Method and Description
private UnlockedHashMap.Item<K,V>[]	addItem(UnlockedHashMap.Item<K,V>[] row, UnlockedHashMap.Item<K,V> newItem)
void	clear()
boolean	containsKey(java.lang.Object key)
private static <K,V> UnlockedHashMap.Item<K,V>[]	createRow(int length)
private static <K,V> UnlockedHashMap.Item<K,V>[]	createRow(UnlockedHashMap.Item<K,V> newItem)
private UnlockedHashMap.TableIterator	createRowIterator(UnlockedHashMap.Table<K,V> table, int rowIdx)
private V	doGet(UnlockedHashMap.Table<K,V> table, K key)
private V	doPut(K key, V value, boolean ifAbsent, UnlockedHashMap.Table<K,V> table)
private V	doRemove(K key, UnlockedHashMap.Table<K,V> table)
private boolean	doRemove(K key, V value, UnlockedHashMap.Table<K,V> table)
private boolean	doRemove(UnlockedHashMap.Item<K,V> item, UnlockedHashMap.Table<K,V> table)
private V	doReplace(K key, V value, UnlockedHashMap.Table<K,V> table)
private boolean	doReplace(K key, V oldValue, V newValue, UnlockedHashMap.Table<K,V> table)
java.util.Set<java.util.Map.Entry<K,V>>	entrySet()
V	get(java.lang.Object key)
private static int	hashCode(java.lang.Object key)
java.util.Set<K>	keySet()
private static <V> V	nonexistent()
V	put(K key, V value)
V	putIfAbsent(K key, V value)
V	remove(java.lang.Object objectKey)
boolean	remove(java.lang.Object objectKey, java.lang.Object objectValue)
private static <K,V> UnlockedHashMap.Item<K,V>[]	remove(UnlockedHashMap.Item<K,V>[] row, int idx)
V	replace(K key, V value)
boolean	replace(K key, V oldValue, V newValue)
private void	resize(UnlockedHashMap.Table<K,V> origTable)
private static <K,V> UnlockedHashMap.Item<K,V>[]	resized()
int	size()
java.util.Collection<V>	values()

Methods inherited from class java.util.AbstractMap

clone, containsValue, equals, hashCode, isEmpty, putAll, toString

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.ConcurrentMap

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map

containsValue, equals, hashCode, isEmpty, putAll

Field Detail

DEFAULT_INITIAL_CAPACITY

private static final int DEFAULT_INITIAL_CAPACITY

See Also:

Constant Field Values

MAXIMUM_CAPACITY

private static final int MAXIMUM_CAPACITY

See Also:

Constant Field Values

DEFAULT_LOAD_FACTOR

private static final float DEFAULT_LOAD_FACTOR

See Also:

Constant Field Values

RESIZED

private static final UnlockedHashMap.Item<?,?>[] RESIZED

A row which has been resized into the new view.

NONEXISTENT

private static final java.lang.Object NONEXISTENT

A non-existent table entry (as opposed to a null value).

table

private volatile UnlockedHashMap.Table<K,V> table

keySet

private final java.util.Set<K> keySet

entrySet

private final java.util.Set<java.util.Map.Entry<K,V>> entrySet

values

private final java.util.Collection<V> values

loadFactor

private final float loadFactor

initialCapacity

private final int initialCapacity

sizeUpdater

private static final java.util.concurrent.atomic.AtomicIntegerFieldUpdater<UnlockedHashMap.Table> sizeUpdater

tableUpdater

private static final java.util.concurrent.atomic.AtomicReferenceFieldUpdater<UnlockedHashMap,UnlockedHashMap.Table> tableUpdater

valueUpdater

private static final java.util.concurrent.atomic.AtomicReferenceFieldUpdater<UnlockedHashMap.Item,java.lang.Object> valueUpdater

Constructor Detail

UnlockedHashMap

public UnlockedHashMap(int initialCapacity,
                       float loadFactor)

Construct a new instance.

Parameters:

initialCapacity - the initial capacity

loadFactor - the load factor

UnlockedHashMap

public UnlockedHashMap(float loadFactor)

Construct a new instance.

Parameters:

loadFactor - the load factor

UnlockedHashMap

public UnlockedHashMap(int initialCapacity)

Construct a new instance.

Parameters:

initialCapacity - the initial capacity

UnlockedHashMap

public UnlockedHashMap()

Construct a new instance.

Method Detail

addItem

private UnlockedHashMap.Item<K,V>[] addItem(UnlockedHashMap.Item<K,V>[] row,
                                            UnlockedHashMap.Item<K,V> newItem)

createRow

private static <K,V> UnlockedHashMap.Item<K,V>[] createRow(UnlockedHashMap.Item<K,V> newItem)

createRow

private static <K,V> UnlockedHashMap.Item<K,V>[] createRow(int length)

doPut

private V doPut(K key,
                V value,
                boolean ifAbsent,
                UnlockedHashMap.Table<K,V> table)

hashCode

private static int hashCode(java.lang.Object key)

resize

private void resize(UnlockedHashMap.Table<K,V> origTable)

remove

private static <K,V> UnlockedHashMap.Item<K,V>[] remove(UnlockedHashMap.Item<K,V>[] row,
                                                        int idx)

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Specified by:

putIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

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

remove

public boolean remove(java.lang.Object objectKey,
                      java.lang.Object objectValue)

Specified by:

remove in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

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

doRemove

private boolean doRemove(UnlockedHashMap.Item<K,V> item,
                         UnlockedHashMap.Table<K,V> table)

doRemove

private boolean doRemove(K key,
                         V value,
                         UnlockedHashMap.Table<K,V> table)

remove

public V remove(java.lang.Object objectKey)

Specified by:

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

Overrides:

remove in class java.util.AbstractMap<K,V>

doRemove

private V doRemove(K key,
                   UnlockedHashMap.Table<K,V> table)

nonexistent

private static <V> V nonexistent()

resized

private static <K,V> UnlockedHashMap.Item<K,V>[] resized()

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

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

doReplace

private boolean doReplace(K key,
                          V oldValue,
                          V newValue,
                          UnlockedHashMap.Table<K,V> table)

replace

public V replace(K key,
                 V value)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

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

doReplace

private V doReplace(K key,
                    V value,
                    UnlockedHashMap.Table<K,V> table)

size

public int size()

Specified by:

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

Overrides:

size in class java.util.AbstractMap<K,V>

doGet

private V doGet(UnlockedHashMap.Table<K,V> table,
                K key)

containsKey

public boolean containsKey(java.lang.Object key)

Specified by:

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

Overrides:

containsKey in class java.util.AbstractMap<K,V>

get

public V get(java.lang.Object key)

Specified by:

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

Overrides:

get in class java.util.AbstractMap<K,V>

put

public V put(K key,
             V value)

Specified by:

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

Overrides:

put in class java.util.AbstractMap<K,V>

clear

public void clear()

Specified by:

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

Overrides:

clear in class java.util.AbstractMap<K,V>

entrySet

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

Specified by:

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

Specified by:

entrySet in class java.util.AbstractMap<K,V>

values

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

Specified by:

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

Overrides:

values in class java.util.AbstractMap<K,V>

keySet

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

Specified by:

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

Overrides:

keySet in class java.util.AbstractMap<K,V>

createRowIterator

private UnlockedHashMap.TableIterator createRowIterator(UnlockedHashMap.Table<K,V> table,
                                                        int rowIdx)