org.springframework.util

Class ConcurrentReferenceHashMap.Segment

java.lang.Object

java.util.concurrent.locks.ReentrantLock

org.springframework.util.ConcurrentReferenceHashMap.Segment

All Implemented Interfaces:

java.io.Serializable, java.util.concurrent.locks.Lock

Enclosing class:

ConcurrentReferenceHashMap<K,V>

protected final class ConcurrentReferenceHashMap.Segment
extends java.util.concurrent.locks.ReentrantLock

A single segment used to divide the map to allow better concurrent performance.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
private int	count The total number of references contained in this segment.
private int	initialSize
private ConcurrentReferenceHashMap.ReferenceManager	referenceManager
private ConcurrentReferenceHashMap.Reference<K,V>[]	references Array of references indexed using the low order bits from the hash.
private int	resizeThreshold The threshold when resizing of the references should occur.

Constructor Summary

Constructors

Constructor and Description
Segment(int initialCapacity)

Method Summary

Modifier and Type	Method and Description
void	clear() Clear all items from this segment.
private ConcurrentReferenceHashMap.Reference<K,V>[]	createReferenceArray(int size)
<T> T	doTask(int hash, java.lang.Object key, ConcurrentReferenceHashMap.Task<T> task) Apply an update operation to this segment.
private ConcurrentReferenceHashMap.Reference<K,V>	findInChain(ConcurrentReferenceHashMap.Reference<K,V> reference, java.lang.Object key, int hash)
int	getCount()
private int	getIndex(int hash, ConcurrentReferenceHashMap.Reference<K,V>[] references)
ConcurrentReferenceHashMap.Reference<K,V>	getReference(java.lang.Object key, int hash, ConcurrentReferenceHashMap.Restructure restructure)
int	getSize()
protected void	restructureIfNecessary(boolean allowResize) Restructure the underlying data structure when it becomes necessary.
private void	setReferences(ConcurrentReferenceHashMap.Reference<K,V>[] references) Replace the references with a new value, recalculating the resizeThreshold.

Methods inherited from class java.util.concurrent.locks.ReentrantLock

getHoldCount, getOwner, getQueuedThreads, getQueueLength, getWaitingThreads, getWaitQueueLength, hasQueuedThread, hasQueuedThreads, hasWaiters, isFair, isHeldByCurrentThread, isLocked, lock, lockInterruptibly, newCondition, toString, tryLock, tryLock, unlock

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

referenceManager

private final ConcurrentReferenceHashMap.ReferenceManager referenceManager

initialSize

private final int initialSize

references

private volatile ConcurrentReferenceHashMap.Reference<K,V>[] references

Array of references indexed using the low order bits from the hash. This property should only be set via setReferences(org.springframework.util.ConcurrentReferenceHashMap.Reference<K, V>[]) to ensure that the resizeThreshold is maintained.

count

private volatile int count

The total number of references contained in this segment. This includes chained references and references that have been garbage collected but not purged.

resizeThreshold

private int resizeThreshold

The threshold when resizing of the references should occur. When count exceeds this value references will be resized.

Constructor Detail

Segment

public Segment(int initialCapacity)

Method Detail

getReference

public ConcurrentReferenceHashMap.Reference<K,V> getReference(java.lang.Object key,
                                                              int hash,
                                                              ConcurrentReferenceHashMap.Restructure restructure)

doTask

public <T> T doTask(int hash,
                    java.lang.Object key,
                    ConcurrentReferenceHashMap.Task<T> task)

Apply an update operation to this segment. The segment will be locked during the update.

Parameters:

hash - the hash of the key

key - the key

task - the update operation

Returns:

the result of the operation

clear

public void clear()

Clear all items from this segment.

restructureIfNecessary

protected final void restructureIfNecessary(boolean allowResize)

Restructure the underlying data structure when it becomes necessary. This method can increase the size of the references table as well as purge any references that have been garbage collected.

Parameters:

allowResize - if resizing is permitted

findInChain

private ConcurrentReferenceHashMap.Reference<K,V> findInChain(ConcurrentReferenceHashMap.Reference<K,V> reference,
                                                              java.lang.Object key,
                                                              int hash)

createReferenceArray

private ConcurrentReferenceHashMap.Reference<K,V>[] createReferenceArray(int size)

getIndex

private int getIndex(int hash,
                     ConcurrentReferenceHashMap.Reference<K,V>[] references)

setReferences

private void setReferences(ConcurrentReferenceHashMap.Reference<K,V>[] references)

Replace the references with a new value, recalculating the resizeThreshold.

Parameters:

references - the new references

getSize

public final int getSize()

Returns:

the size of the current references array

getCount

public final int getCount()

Returns:

the total number of references in this segment