org.apache.solr.util

Class ConcurrentLRUCache<K,V>

java.lang.Object

org.apache.solr.util.ConcurrentLRUCache<K,V>

All Implemented Interfaces:

Accountable, Cache<K,V>

public class ConcurrentLRUCache<K,V>
extends Object
implements Cache<K,V>, Accountable

A LRU cache implementation based upon ConcurrentHashMap and other techniques to reduce contention and synchronization overhead to utilize multiple CPU cores more effectively.

Note that the implementation does not follow a true LRU (least-recently-used) eviction strategy. Instead it strives to remove least recently used items but when the initial cleanup does not remove enough items to reach the 'acceptableWaterMark' limit, it can remove more items forcefully regardless of access order.

Since:

solr 1.4

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ConcurrentLRUCache.CacheEntry<K,V>
static interface	ConcurrentLRUCache.EvictionListener<K,V>
static class	ConcurrentLRUCache.Stats

Field Summary

Fields inherited from interface org.apache.lucene.util.Accountable

NULL_ACCOUNTABLE

Constructor Summary

Constructors

Constructor and Description
ConcurrentLRUCache(int size, int lowerWatermark)
ConcurrentLRUCache(int upperWaterMark, int lowerWaterMark, int acceptableWatermark, int initialSize, boolean runCleanupThread, boolean runNewThreadForCleanup, ConcurrentLRUCache.EvictionListener<K,V> evictionListener)
ConcurrentLRUCache(int upperWaterMark, int lowerWaterMark, int acceptableWatermark, int initialSize, boolean runCleanupThread, boolean runNewThreadForCleanup, ConcurrentLRUCache.EvictionListener<K,V> evictionListener, int maxIdleTimeSec)
ConcurrentLRUCache(long ramLowerWatermark, long ramUpperWatermark, boolean runCleanupThread, ConcurrentLRUCache.EvictionListener<K,V> evictionListener)
ConcurrentLRUCache(long ramLowerWatermark, long ramUpperWatermark, boolean runCleanupThread, ConcurrentLRUCache.EvictionListener<K,V> evictionListener, int maxIdleTimeSec)

Method Summary

Modifier and Type	Method and Description
void	clear()
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
void	destroy()
protected void	finalize()
V	get(K key)
Collection<Accountable>	getChildResources()
Map<K,V>	getLatestAccessedItems(int n)
Map<Object,ConcurrentLRUCache.CacheEntry<K,V>>	getMap()
Map<K,V>	getOldestAccessedItems(int n) Returns 'n' number of oldest accessed entries present in this cache.
ConcurrentLRUCache.Stats	getStats()
void	markAndSweep() Removes items from the cache to bring the size down to an acceptable value.
V	put(K key, V val)
V	putCacheEntry(ConcurrentLRUCache.CacheEntry<K,V> e) Visible for testing to create synthetic cache entries.
long	ramBytesUsed()
V	remove(K key)
void	setAcceptableWaterMark(int acceptableWaterMark)
void	setAlive(boolean live)
void	setLowerWaterMark(int lowerWaterMark)
void	setMaxIdleTime(int maxIdleTime)
void	setRamLowerWatermark(long ramLowerWatermark)
void	setRamUpperWatermark(long ramUpperWatermark)
void	setRunCleanupThread(boolean runCleanupThread)
void	setUpperWaterMark(int upperWaterMark)
int	size()

Methods inherited from class java.lang.Object

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

Constructor Detail

ConcurrentLRUCache

public ConcurrentLRUCache(long ramLowerWatermark,
                          long ramUpperWatermark,
                          boolean runCleanupThread,
                          ConcurrentLRUCache.EvictionListener<K,V> evictionListener)

ConcurrentLRUCache

public ConcurrentLRUCache(long ramLowerWatermark,
                          long ramUpperWatermark,
                          boolean runCleanupThread,
                          ConcurrentLRUCache.EvictionListener<K,V> evictionListener,
                          int maxIdleTimeSec)

ConcurrentLRUCache

public ConcurrentLRUCache(int upperWaterMark,
                          int lowerWaterMark,
                          int acceptableWatermark,
                          int initialSize,
                          boolean runCleanupThread,
                          boolean runNewThreadForCleanup,
                          ConcurrentLRUCache.EvictionListener<K,V> evictionListener)

ConcurrentLRUCache

public ConcurrentLRUCache(int upperWaterMark,
                          int lowerWaterMark,
                          int acceptableWatermark,
                          int initialSize,
                          boolean runCleanupThread,
                          boolean runNewThreadForCleanup,
                          ConcurrentLRUCache.EvictionListener<K,V> evictionListener,
                          int maxIdleTimeSec)

ConcurrentLRUCache

public ConcurrentLRUCache(int size,
                          int lowerWatermark)

Method Detail

setAlive

public void setAlive(boolean live)

setUpperWaterMark

public void setUpperWaterMark(int upperWaterMark)

setLowerWaterMark

public void setLowerWaterMark(int lowerWaterMark)

setAcceptableWaterMark

public void setAcceptableWaterMark(int acceptableWaterMark)

setRamUpperWatermark

public void setRamUpperWatermark(long ramUpperWatermark)

setRamLowerWatermark

public void setRamLowerWatermark(long ramLowerWatermark)

setMaxIdleTime

public void setMaxIdleTime(int maxIdleTime)

setRunCleanupThread

public void setRunCleanupThread(boolean runCleanupThread)

get

public V get(K key)

Specified by:

get in interface Cache<K,V>

remove

public V remove(K key)

Specified by:

remove in interface Cache<K,V>

computeIfAbsent

public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)

Specified by:

computeIfAbsent in interface Cache<K,V>

put

public V put(K key,
             V val)

Specified by:

put in interface Cache<K,V>

putCacheEntry

public V putCacheEntry(ConcurrentLRUCache.CacheEntry<K,V> e)

Visible for testing to create synthetic cache entries.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

markAndSweep

public void markAndSweep()

Removes items from the cache to bring the size down to an acceptable value.

Visible for unit testing.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

getOldestAccessedItems

public Map<K,V> getOldestAccessedItems(int n)

Returns 'n' number of oldest accessed entries present in this cache. This uses a TreeSet to collect the 'n' oldest items ordered by ascending last access time and returns a LinkedHashMap containing 'n' or less than 'n' entries.

Parameters:

n - the number of oldest items needed

Returns:

a LinkedHashMap containing 'n' or less than 'n' entries

getLatestAccessedItems

public Map<K,V> getLatestAccessedItems(int n)

size

public int size()

clear

public void clear()

Specified by:

clear in interface Cache<K,V>

getMap

public Map<Object,ConcurrentLRUCache.CacheEntry<K,V>> getMap()

destroy

public void destroy()

getStats

public ConcurrentLRUCache.Stats getStats()

finalize

protected void finalize()
                 throws Throwable

Overrides:

finalize in class Object

Throws:

Throwable

ramBytesUsed

public long ramBytesUsed()

Specified by:

ramBytesUsed in interface Accountable

getChildResources

public Collection<Accountable> getChildResources()

Specified by:

getChildResources in interface Accountable