com.reardencommerce.kernel.collections.shared.evictable
Class ConcurrentLinkedHashMap<K,V>

java.lang.Object
  extended by java.util.AbstractMap<K,V>
      extended by com.reardencommerce.kernel.collections.shared.evictable.ConcurrentLinkedHashMap<K,V>
All Implemented Interfaces:
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 ConcurrentMap with a doubly-linked list running through its entries.

This class provides the same semantics as a ConcurrentHashMap in terms of iterators, acceptable keys, and concurrency characteristics, but perform slightly worse due to the added expense of maintaining the linked list. It differs from LinkedHashMap in that it does not provide predictable iteration order.

This map is intended to be used for caches and provides the following eviction policies:

Author:
Ben Manes
See Also:
http://code.google.com/p/concurrentlinkedhashmap/, Serialized Form

Nested Class Summary
static interface ConcurrentLinkedHashMap.EvictionListener<K,V>
          A listener registered for notification when an entry is evicted.
static class ConcurrentLinkedHashMap.EvictionPolicy
          The replacement policy to apply to determine which entry to discard when the capacity has been reached.
 
Nested classes/interfaces inherited from interface java.util.Map
java.util.Map.Entry<K,V>
 
Method Summary
 int capacity()
          Retrieves the maximum capacity of the map.
 void clear()
          
 boolean containsKey(java.lang.Object key)
          
 boolean containsValue(java.lang.Object value)
          
static
<K,V> ConcurrentLinkedHashMap<K,V>
create(ConcurrentLinkedHashMap.EvictionPolicy policy, int maximumCapacity)
          Creates a map with the specified eviction policy, maximum capacity, and at the default concurrency level.
static
<K,V> ConcurrentLinkedHashMap<K,V>
create(ConcurrentLinkedHashMap.EvictionPolicy policy, int maximumCapacity, ConcurrentLinkedHashMap.EvictionListener<K,V> listener)
          Creates a map with the specified eviction policy, maximum capacity, eviction listener, and at the default concurrency level.
static
<K,V> ConcurrentLinkedHashMap<K,V>
create(ConcurrentLinkedHashMap.EvictionPolicy policy, int maximumCapacity, int concurrencyLevel)
          Creates a map with the specified eviction policy, maximum capacity, and concurrency level.
static
<K,V> ConcurrentLinkedHashMap<K,V>
create(ConcurrentLinkedHashMap.EvictionPolicy policy, int maximumCapacity, int concurrencyLevel, ConcurrentLinkedHashMap.EvictionListener<K,V> listener)
          Creates a map with the specified eviction policy, maximum capacity, eviction listener, and concurrency level.
 java.util.Set<java.util.Map.Entry<K,V>> entrySet()
          
 V get(java.lang.Object key)
          
 java.util.Set<K> keySet()
          
 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(int capacity)
          Sets the maximum capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.
 int size()
          
 java.util.Collection<V> values()
          
 
Methods inherited from class java.util.AbstractMap
clone, 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.Map
equals, hashCode, isEmpty, putAll
 

Method Detail

create

public static <K,V> ConcurrentLinkedHashMap<K,V> create(ConcurrentLinkedHashMap.EvictionPolicy policy,
                                                        int maximumCapacity)
Creates a map with the specified eviction policy, maximum capacity, and at the default concurrency level.

Parameters:
policy - The eviction policy to apply when the size exceeds the maximum capacity.
maximumCapacity - The maximum capacity to coerces to. The size may exceed it temporarily.

create

public static <K,V> ConcurrentLinkedHashMap<K,V> create(ConcurrentLinkedHashMap.EvictionPolicy policy,
                                                        int maximumCapacity,
                                                        ConcurrentLinkedHashMap.EvictionListener<K,V> listener)
Creates a map with the specified eviction policy, maximum capacity, eviction listener, and at the default concurrency level.

Parameters:
policy - The eviction policy to apply when the size exceeds the maximum capacity.
maximumCapacity - The maximum capacity to coerces to. The size may exceed it temporarily.
listener - The listener registered for notification when an entry is evicted.

create

public static <K,V> ConcurrentLinkedHashMap<K,V> create(ConcurrentLinkedHashMap.EvictionPolicy policy,
                                                        int maximumCapacity,
                                                        int concurrencyLevel)
Creates a map with the specified eviction policy, maximum capacity, and concurrency level.

Parameters:
policy - The eviction policy to apply when the size exceeds the maximum capacity.
maximumCapacity - The maximum capacity to coerces to. The size may exceed it temporarily.
concurrencyLevel - The estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads.

create

public static <K,V> ConcurrentLinkedHashMap<K,V> create(ConcurrentLinkedHashMap.EvictionPolicy policy,
                                                        int maximumCapacity,
                                                        int concurrencyLevel,
                                                        ConcurrentLinkedHashMap.EvictionListener<K,V> listener)
Creates a map with the specified eviction policy, maximum capacity, eviction listener, and concurrency level.

Parameters:
policy - The eviction policy to apply when the size exceeds the maximum capacity.
maximumCapacity - The maximum capacity to coerces to. The size may exceed it temporarily.
concurrencyLevel - The estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads.
listener - The listener registered for notification when an entry is evicted.

setCapacity

public void setCapacity(int capacity)
Sets the maximum capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.

Parameters:
capacity - The maximum capacity of the map.

capacity

public int capacity()
Retrieves the maximum capacity of the map.

Returns:
The maximum capacity.

size

public int size()

Specified by:
size in interface java.util.Map<K,V>
Overrides:
size 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>

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>

containsValue

public boolean containsValue(java.lang.Object value)

Specified by:
containsValue in interface java.util.Map<K,V>
Overrides:
containsValue 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>

putIfAbsent

public V putIfAbsent(K key,
                     V value)

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

remove

public V remove(java.lang.Object key)

Specified by:
remove in interface java.util.Map<K,V>
Overrides:
remove in class java.util.AbstractMap<K,V>

remove

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

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

replace

public V replace(K key,
                 V value)

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

replace

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

Specified by:
replace in interface java.util.concurrent.ConcurrentMap<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>

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>

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>


Copyright © 2009 Ignite Realtime. All Rights Reserved.