Class ConcurrentLRUCache<K,​V>

  • All Implemented Interfaces:
    org.apache.lucene.util.Accountable, Cache<K,​V>

    public class ConcurrentLRUCache<K,​V>
    extends Object
    implements Cache<K,​V>, org.apache.lucene.util.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
    • 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>
      • 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>
      • destroy

        public void destroy()
      • ramBytesUsed

        public long ramBytesUsed()
        Specified by:
        ramBytesUsed in interface org.apache.lucene.util.Accountable
      • getChildResources

        public Collection<org.apache.lucene.util.Accountable> getChildResources()
        Specified by:
        getChildResources in interface org.apache.lucene.util.Accountable