LongConcurrentLRUMap

java.lang.Object
- org.mapdb.LongMap<V>
- - org.mapdb.LongConcurrentLRUMap<V>

```
public class LongConcurrentLRUMap<V>
extends LongMap<V>
```
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. MapDB note: reworked to implement LongMap. Original comes from: https://svn.apache.org/repos/asf/lucene/dev/trunk/solr/core/src/java/org/apache/solr/util/ConcurrentLRUCache.java

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`LongConcurrentLRUMap.CacheEntry<V>`
`private static class`	`LongConcurrentLRUMap.PQueue<V>`
`private static class`	`LongConcurrentLRUMap.PriorityQueue<T>` A PriorityQueue maintains a partial ordering of its elements such that the least element can always be found in constant time.

Nested classes/interfaces inherited from class org.mapdb.LongMap
LongMap.LongMapIterator<V>

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`acceptableWaterMark`
`protected java.util.concurrent.atomic.AtomicLong`	`accessCounter`
`protected java.util.concurrent.atomic.AtomicLong`	`evictionCounter`
`protected boolean`	`isCleaning`
`protected int`	`lowerWaterMark`
`protected LongConcurrentHashMap<LongConcurrentLRUMap.CacheEntry<V>>`	`map`
`protected java.util.concurrent.locks.ReentrantLock`	`markAndSweepLock`
`protected java.util.concurrent.atomic.AtomicLong`	`missCounter`
`protected long`	`oldestEntry`
`protected java.util.concurrent.atomic.AtomicLong`	`putCounter`
`protected java.util.concurrent.atomic.AtomicInteger`	`size`
`protected int`	`upperWaterMark`

Constructor Summary

Constructors
Constructor and Description
`LongConcurrentLRUMap(int size, int lowerWatermark)`
`LongConcurrentLRUMap(int upperWaterMark, int lowerWaterMark, int acceptableWatermark, int initialSize)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Removes all mappings from this hash map, leaving it empty.
`protected void`	`evictedEntry(long key, V value)` override this method to get notified about evicted entries
`private void`	`evictEntry(long key)`
`V`	`get(long key)` Returns the value of the mapping with the specified key.
`LongMap<LongConcurrentLRUMap.CacheEntry<V>>`	`getMap()`
`boolean`	`isEmpty()` Returns whether this map is empty.
`LongMap.LongMapIterator<V>`	`longMapIterator()`
`private void`	`markAndSweep()` Removes items from the cache to bring the size down to an acceptable value ('acceptableWaterMark').
`V`	`put(long key, V val)` Maps the specified key to the specified value.
`V`	`remove(long key)` Removes the mapping from this map
`int`	`size()` Returns the number of elements in this map.
`java.util.Iterator<V>`	`valuesIterator()`

Methods inherited from class org.mapdb.LongMap
toString

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

- Field Detail
  - map
```
protected final LongConcurrentHashMap<LongConcurrentLRUMap.CacheEntry<V>> map
```
  - upperWaterMark
```
protected final int upperWaterMark
```
  - lowerWaterMark
```
protected final int lowerWaterMark
```
  - markAndSweepLock
```
protected final java.util.concurrent.locks.ReentrantLock markAndSweepLock
```
  - isCleaning
```
protected boolean isCleaning
```
  - acceptableWaterMark
```
protected final int acceptableWaterMark
```
  - oldestEntry
```
protected long oldestEntry
```
  - accessCounter
```
protected final java.util.concurrent.atomic.AtomicLong accessCounter
```
  - putCounter
```
protected final java.util.concurrent.atomic.AtomicLong putCounter
```
  - missCounter
```
protected final java.util.concurrent.atomic.AtomicLong missCounter
```
  - evictionCounter
```
protected final java.util.concurrent.atomic.AtomicLong evictionCounter
```
  - size
```
protected final java.util.concurrent.atomic.AtomicInteger size
```
- Constructor Detail
  - LongConcurrentLRUMap
```
public LongConcurrentLRUMap(int upperWaterMark,
                            int lowerWaterMark,
                            int acceptableWatermark,
                            int initialSize)
```
  - LongConcurrentLRUMap
```
public LongConcurrentLRUMap(int size,
                            int lowerWatermark)
```
- Method Detail
  - get
```
public V get(long key)
```
    Description copied from class: LongMap
    
    Returns the value of the mapping with the specified key.
    
    Specified by:
    
    get in class LongMap<V>
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    the value of the mapping with the specified key, or null if no mapping for the specified key is found.
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from class: LongMap
    
    Returns whether this map is empty.
    
    Specified by:
    
    isEmpty in class LongMap<V>
    
    Returns:
    
    true if this map has no elements, false otherwise.
    
    See Also:
    
    LongMap.size()
  - remove
```
public V remove(long key)
```
    Description copied from class: LongMap
    
    Removes the mapping from this map
    
    Specified by:
    
    remove in class LongMap<V>
    
    Parameters:
    
    key - to remove
    
    Returns:
    
    value contained under this key, or null if value did not exist
  - put
```
public V put(long key,
             V val)
```
    Description copied from class: LongMap
    
    Maps the specified key to the specified value.
    
    Specified by:
    
    put in class LongMap<V>
    
    Parameters:
    
    key - the key.
    
    val - the value.
    
    Returns:
    
    the value of any previous mapping with the specified key or null if there was no such mapping.
  - markAndSweep
```
private void markAndSweep()
```
    Removes items from the cache to bring the size down to an acceptable value ('acceptableWaterMark').
    It is done in two stages. In the first stage, least recently used items are evicted. If, after the first stage, the cache size is still greater than 'acceptableSize' config parameter, the second stage takes over.
    The second stage is more intensive and tries to bring down the cache size to the 'lowerWaterMark' config parameter.
  - evictEntry
```
private void evictEntry(long key)
```
  - size
```
public int size()
```
    Description copied from class: LongMap
    
    Returns the number of elements in this map.
    
    Specified by:
    
    size in class LongMap<V>
    
    Returns:
    
    the number of elements in this map.
  - valuesIterator
```
public java.util.Iterator<V> valuesIterator()
```
    Specified by:
    
    valuesIterator in class LongMap<V>
    
    Returns:
    
    iterator over values in map
  - longMapIterator
```
public LongMap.LongMapIterator<V> longMapIterator()
```
    Specified by:
    
    longMapIterator in class LongMap<V>
  - clear
```
public void clear()
```
    Description copied from class: LongMap
    
    Removes all mappings from this hash map, leaving it empty.
    
    Specified by:
    
    clear in class LongMap<V>
    
    See Also:
    
    LongMap.isEmpty(), LongMap.size()
  - getMap
```
public LongMap<LongConcurrentLRUMap.CacheEntry<V>> getMap()
```
  - evictedEntry
```
protected void evictedEntry(long key,
                            V value)
```
    override this method to get notified about evicted entries

Class LongConcurrentLRUMap<V>

Nested Class Summary

Nested classes/interfaces inherited from class org.mapdb.LongMap

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.mapdb.LongMap

Methods inherited from class java.lang.Object

Field Detail

map

upperWaterMark

lowerWaterMark

markAndSweepLock

isCleaning

acceptableWaterMark

oldestEntry

accessCounter

putCounter

missCounter

evictionCounter

size

Constructor Detail

LongConcurrentLRUMap

LongConcurrentLRUMap

Method Detail

get

isEmpty

remove

put

markAndSweep

evictEntry

size

valuesIterator

longMapIterator

clear

getMap

evictedEntry