jmind.core.cache.support

类 ConcurrentLinkedHashMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

jmind.core.cache.support.ConcurrentLinkedHashMap<K,V>

类型参数:

K - the type of keys maintained by this map

V - the type of mapped values

所有已实现的接口:

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

public final class ConcurrentLinkedHashMap<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.concurrent.ConcurrentMap<K,V>, java.io.Serializable

A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by. This implementation differs from ConcurrentHashMap in that it maintains a page replacement algorithm that is used to evict an entry when the map has exceeded its capacity. Unlike the Java Collections Framework, this map does not have a publicly visible constructor and instances are created through a ConcurrentLinkedHashMap.Builder.

An entry is evicted from the map when the weighted capacity exceeds its maximum weighted capacity threshold. A EntryWeigher determines how many units of capacity that an entry consumes. The default weigher assigns each value a weight of 1 to bound the map by the total number of key-value pairs. A map that holds collections may choose to weigh values by the number of elements in the collection and bound the map by the total number of elements that it contains. A change to a value that modifies its weight requires that an update operation is performed on the map.

An EvictionListener may be supplied for notification when an entry is evicted from the map. This listener is invoked on a caller's thread and will not block other threads from operating on the map. An implementation should be aware that the caller's thread will not expect long execution times or failures as a side effect of the listener being notified. Execution safety and a fast turn around time can be achieved by performing the operation asynchronously, such as by submitting a task to an ExecutorService.

The concurrency level determines the number of threads that can concurrently modify the table. Using a significantly higher or lower value than needed can waste space or lead to thread contention, but an estimate within an order of magnitude of the ideal value does not usually have a noticeable impact. Because placement in hash tables is essentially random, the actual concurrency will vary.

This class and its views and iterators implement all of the optional methods of the Map and Iterator interfaces.

Like Hashtable but unlike HashMap, this class does not allow null to be used as a key or value. Unlike LinkedHashMap, this class does not provide predictable iteration order. A snapshot of the keys and entries may be obtained in ascending and descending order of retention.

作者:

ben.manes@gmail.com (Ben Manes)

另请参阅:

http://code.google.com/p/concurrentlinkedhashmap/, 序列化表格

嵌套类概要

嵌套类

限定符和类型	类和说明
static class	ConcurrentLinkedHashMap.Builder<K,V> A builder that creates ConcurrentLinkedHashMap instances.

从类继承的嵌套类/接口 java.util.AbstractMap

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

从接口继承的嵌套类/接口 java.util.Map

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

方法概要

限定符和类型	方法和说明
java.util.Set<K>	ascendingKeySet() Returns a unmodifiable snapshot Set view of the keys contained in this map.
java.util.Set<K>	ascendingKeySetWithLimit(int limit) Returns an unmodifiable snapshot Set view of the keys contained in this map.
java.util.Map<K,V>	ascendingMap() Returns an unmodifiable snapshot Map view of the mappings contained in this map.
java.util.Map<K,V>	ascendingMapWithLimit(int limit) Returns an unmodifiable snapshot Map view of the mappings contained in this map.
long	capacity() Retrieves the maximum weighted capacity of the map.
void	clear()
boolean	containsKey(java.lang.Object key)
boolean	containsValue(java.lang.Object value)
java.util.Set<K>	descendingKeySet() Returns an unmodifiable snapshot Set view of the keys contained in this map.
java.util.Set<K>	descendingKeySetWithLimit(int limit) Returns an unmodifiable snapshot Set view of the keys contained in this map.
java.util.Map<K,V>	descendingMap() Returns an unmodifiable snapshot Map view of the mappings contained in this map.
java.util.Map<K,V>	descendingMapWithLimit(int limit) Returns an unmodifiable snapshot Map view of the mappings contained in this map.
java.util.Set<java.util.Map.Entry<K,V>>	entrySet()
V	get(java.lang.Object key)
V	getQuietly(java.lang.Object key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
boolean	isEmpty()
java.util.Set<K>	keySet()
static void	main(java.lang.String[] args)
V	put(K key, V value)
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)
void	setCapacity(long capacity) Sets the maximum weighted capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.
int	size()
java.util.Collection<V>	values()
long	weightedSize() Returns the weighted size of this map.

从类继承的方法 java.util.AbstractMap

clone, equals, hashCode, putAll, toString

从类继承的方法 java.lang.Object

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

从接口继承的方法 java.util.concurrent.ConcurrentMap

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

从接口继承的方法 java.util.Map

equals, hashCode, putAll

方法详细资料

capacity

public long capacity()

Retrieves the maximum weighted capacity of the map.

返回:

the maximum weighted capacity

setCapacity

public void setCapacity(long capacity)

Sets the maximum weighted capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.

参数:

capacity - the maximum weighted capacity of the map

抛出:

java.lang.IllegalArgumentException - if the capacity is negative

isEmpty

public boolean isEmpty()

指定者:

isEmpty 在接口中 java.util.Map<K,V>

覆盖:

isEmpty 在类中 java.util.AbstractMap<K,V>

size

public int size()

指定者:

size 在接口中 java.util.Map<K,V>

覆盖:

size 在类中 java.util.AbstractMap<K,V>

weightedSize

public long weightedSize()

Returns the weighted size of this map.

返回:

the combined weight of the values in this map

clear

public void clear()

指定者:

clear 在接口中 java.util.Map<K,V>

覆盖:

clear 在类中 java.util.AbstractMap<K,V>

containsKey

public boolean containsKey(java.lang.Object key)

指定者:

containsKey 在接口中 java.util.Map<K,V>

覆盖:

containsKey 在类中 java.util.AbstractMap<K,V>

containsValue

public boolean containsValue(java.lang.Object value)

指定者:

containsValue 在接口中 java.util.Map<K,V>

覆盖:

containsValue 在类中 java.util.AbstractMap<K,V>

get

public V get(java.lang.Object key)

指定者:

get 在接口中 java.util.Map<K,V>

覆盖:

get 在类中 java.util.AbstractMap<K,V>

getQuietly

public V getQuietly(java.lang.Object key)

Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. This method differs from get(Object) in that it does not record the operation with the page replacement policy.

参数:

key - the key whose associated value is to be returned

返回:

the value to which the specified key is mapped, or null if this map contains no mapping for the key

抛出:

java.lang.NullPointerException - if the specified key is null

put

public V put(K key,
             V value)

指定者:

put 在接口中 java.util.Map<K,V>

覆盖:

put 在类中 java.util.AbstractMap<K,V>

putIfAbsent

public V putIfAbsent(K key,
                     V value)

指定者:

putIfAbsent 在接口中 java.util.concurrent.ConcurrentMap<K,V>

指定者:

putIfAbsent 在接口中 java.util.Map<K,V>

remove

public V remove(java.lang.Object key)

指定者:

remove 在接口中 java.util.Map<K,V>

覆盖:

remove 在类中 java.util.AbstractMap<K,V>

remove

public boolean remove(java.lang.Object key,
                      java.lang.Object value)

指定者:

remove 在接口中 java.util.concurrent.ConcurrentMap<K,V>

指定者:

remove 在接口中 java.util.Map<K,V>

replace

public V replace(K key,
                 V value)

指定者:

replace 在接口中 java.util.concurrent.ConcurrentMap<K,V>

指定者:

replace 在接口中 java.util.Map<K,V>

replace

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

指定者:

replace 在接口中 java.util.concurrent.ConcurrentMap<K,V>

指定者:

replace 在接口中 java.util.Map<K,V>

keySet

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

指定者:

keySet 在接口中 java.util.Map<K,V>

覆盖:

keySet 在类中 java.util.AbstractMap<K,V>

ascendingKeySet

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

Returns a unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.

Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.

返回:

an ascending snapshot view of the keys in this map

ascendingKeySetWithLimit

public java.util.Set<K> ascendingKeySetWithLimit(int limit)

Returns an unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.

Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.

参数:

limit - the maximum size of the returned set

返回:

a ascending snapshot view of the keys in this map

抛出:

java.lang.IllegalArgumentException - if the limit is negative

descendingKeySet

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

Returns an unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.

Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.

返回:

a descending snapshot view of the keys in this map

descendingKeySetWithLimit

public java.util.Set<K> descendingKeySetWithLimit(int limit)

Returns an unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.

Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.

参数:

limit - the maximum size of the returned set

返回:

a descending snapshot view of the keys in this map

抛出:

java.lang.IllegalArgumentException - if the limit is negative

values

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

指定者:

values 在接口中 java.util.Map<K,V>

覆盖:

values 在类中 java.util.AbstractMap<K,V>

entrySet

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

指定者:

entrySet 在接口中 java.util.Map<K,V>

指定者:

entrySet 在类中 java.util.AbstractMap<K,V>

ascendingMap

public java.util.Map<K,V> ascendingMap()

Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.

Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.

返回:

a ascending snapshot view of this map

ascendingMapWithLimit

public java.util.Map<K,V> ascendingMapWithLimit(int limit)

Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.

Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.

参数:

limit - the maximum size of the returned map

返回:

a ascending snapshot view of this map

抛出:

java.lang.IllegalArgumentException - if the limit is negative

descendingMap

public java.util.Map<K,V> descendingMap()

Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.

Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.

返回:

a descending snapshot view of this map

descendingMapWithLimit

public java.util.Map<K,V> descendingMapWithLimit(int limit)

Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.

Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.

参数:

limit - the maximum size of the returned map

返回:

a descending snapshot view of this map

抛出:

java.lang.IllegalArgumentException - if the limit is negative

main

public static void main(java.lang.String[] args)