## org.apache.solr.common.util
Class ConcurrentLRUCache<K,V>

    java.lang.Object
      org.apache.solr.common.util.ConcurrentLRUCache<K,V>

    public class ConcurrentLRUCache<K,V>

extends Object

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
Version:
  $Id: ConcurrentLRUCache.java 1065312 2011-01-30 16:08:25Z rmuir $

Nested Class Summary
`static interface` `ConcurrentLRUCache.EvictionListener<K,V>`
`static class` `ConcurrentLRUCache.Stats`

Constructor Summary
`ConcurrentLRUCache(int size, int lowerWatermark)`
`ConcurrentLRUCache(int upperWaterMark, int lowerWaterMark, int acceptableWatermark, int initialSize, boolean runCleanupThread, boolean runNewThreadForCleanup, ConcurrentLRUCache.EvictionListener<K,V> evictionListener)`

Method Summary
`void` `clear()`
`void` `destroy()`
`protected void` `finalize()`
`V` `get(K key)`
`Map<K,V>` `getLatestAccessedItems(int n)`
`Map<Object,org.apache.solr.common.util.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()`
`V` `put(K key, V val)`
`V` `remove(K key)`
`void` `setAlive(boolean live)`
`int` `size()`

Methods inherited from class java.lang.Object
`clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ConcurrentLRUCache

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

### ConcurrentLRUCache

    public ConcurrentLRUCache(int size,
                              int lowerWatermark)

Method Detail

### setAlive

    public void setAlive(boolean live)

### get

    public V get(K key)

### remove

    public V remove(K key)

### put

    public V put(K key,
                 V val)

### 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()

### getMap

    public Map<Object,org.apache.solr.common.util.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`

Copyright © 2011 Apache Software Foundation. All Rights Reserved.