LRU ist die Abkürzung für „Least Latest Used“, was übersetzt „zuletzt verwendet“ bedeutet. Einfach ausgedrückt wird eine bestimmte Datenmenge zwischengespeichert es überschreitet Wenn der Schwellenwert festgelegt ist, werden einige abgelaufene Daten gelöscht.
Zum Beispiel speichern wir 10.000 Daten im Cache. Wenn die Datenmenge weniger als 10.000 beträgt, können wir sie nach Belieben hinzufügen. Um dies sicherzustellen, müssen wir neue Daten hinzufügen und die abgelaufenen Daten löschen Wir speichern maximal 10.000 Teile. Wie lässt sich also ermitteln, welche abgelaufenen Daten gelöscht werden sollen? Bei Verwendung des LRU-Algorithmus werden die ältesten Daten gelöscht.
Lassen Sie uns über die Java-Version der LRU-Cache-Implementierung sprechen: (Empfohlen: Java-Video-Tutorial)
Normalerweise gibt es zwei Optionen für die Implementierung des LRU-Cache in Java, eine davon ist Um LinkedHashMap zu verwenden, müssen Sie die Datenstruktur mithilfe einer verknüpften Liste + HashMap selbst entwerfen
LinkedHashMap-Implementierung von LRU Cache
LinkedHashMap selbst hat es implementiert Die Sequenzspeicherung speichert Elemente standardmäßig in der Reihenfolge, in der sie hinzugefügt werden. Sie können die Speicherung auch in der Zugriffsreihenfolge aktivieren, d. h. die zuletzt gelesenen Daten werden vorne platziert, die frühesten gelesenen Daten werden am Ende platziert Dann wird auch entschieden, ob die ältesten Daten gelöscht werden sollen. Sie geben standardmäßig false zurück, dh die Daten werden nicht gelöscht.
Die Art und Weise, wie wir LinkedHashMap zum Implementieren von LRU-Caching verwenden, besteht darin, eine einfache Erweiterung von LinkedHashMap zu implementieren. Es gibt zwei Erweiterungsmethoden, eine ist Vererbung und die andere ist Delegation.
//LinkedHashMap的一个构造函数，当参数accessOrder为true时，即会按照访问顺序排序，最近访问的放在最前，最早访问的放在后面
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
//LinkedHashMap自带的判断是否删除最老的元素方法，默认返回false，即不删除老数据
//我们要做的就是重写这个方法，当满足一定条件时删除老数据
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}Nach dem Login kopieren
LRU-Cache-LinkedHashMap-Implementierung (Vererbung)
Die Vererbungsmethode ist relativ einfach zu implementieren und implementiert die Map-Schnittstelle und kann dies auch sein Wird in einer Multithread-Umgebung verwendet. Sie können die Methode Collections.synchronizedMap() verwenden, um threadsichere Vorgänge zu implementieren.
package cn.lzrabbit.structure.lru;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Created by liuzhao on 14-5-15.
*/
public class LRUCache2<K, V> extends LinkedHashMap<K, V> {
private final int MAX_CACHE_SIZE;
public LRUCache2(int cacheSize) {
super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
MAX_CACHE_SIZE = cacheSize;
}
@Override
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > MAX_CACHE_SIZE;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (Map.Entry<K, V> entry : entrySet()) {
sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
}
return sb.toString();
}
}Nach dem Login kopieren
Dies ist eine relativ standardmäßige Implementierung. Im tatsächlichen Gebrauch ist das Schreiben auf diese Weise immer noch etwas umständlich. Eine praktischere Methode besteht darin, wie folgt zu schreiben und die Mühe wegzulassen, eine Klasse allein zu sehen
final int cacheSize = 100;
Map<String, String> map = new LinkedHashMap<String, String>((int) Math.ceil(cacheSize / 0.75f) + 1, 0.75f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
return size() > cacheSize;
}
};Nach dem Login kopieren
LRU-Cache LinkedHashMap (Delegation) Implementierung
Die Delegationsmethode ist eleganter, aber da Map keine implementierte Schnittstelle ist, muss die Thread-Synchronisierung selbst durchgeführt werden
package cn.lzrabbit.structure.lru;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* Created by liuzhao on 14-5-13.
*/
public class LRUCache3<K, V> {
private final int MAX_CACHE_SIZE;
private final float DEFAULT_LOAD_FACTOR = 0.75f;
LinkedHashMap<K, V> map;
public LRUCache3(int cacheSize) {
MAX_CACHE_SIZE = cacheSize;
//根据cacheSize和加载因子计算hashmap的capactiy，+1确保当达到cacheSize上限时不会触发hashmap的扩容，
int capacity = (int) Math.ceil(MAX_CACHE_SIZE / DEFAULT_LOAD_FACTOR) + 1;
map = new LinkedHashMap(capacity, DEFAULT_LOAD_FACTOR, true) {
@Override
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > MAX_CACHE_SIZE;
}
};
}
public synchronized void put(K key, V value) {
map.put(key, value);
}
public synchronized V get(K key) {
return map.get(key);
}
public synchronized void remove(K key) {
map.remove(key);
}
public synchronized Set<Map.Entry<K, V>> getAll() {
return map.entrySet();
}
public synchronized int size() {
return map.size();
}
public synchronized void clear() {
map.clear();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (Map.Entry entry : map.entrySet()) {
sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
}
return sb.toString();
}
}Nach dem Login kopieren
LRU-Cache-verknüpfte Liste + HashMap-Implementierung
Hinweis: Diese Implementierung ist nicht threadsicher. Wenn sie in einer Multithread-Umgebung verwendet wird, muss synchronisiert zu den relevanten Methoden hinzugefügt werden, um threadsichere Vorgänge zu erreichen
package cn.lzrabbit.structure.lru;
import java.util.HashMap;
/**
* Created by liuzhao on 14-5-12.
*/
public class LRUCache1<K, V> {
private final int MAX_CACHE_SIZE;
private Entry first;
private Entry last;
private HashMap<K, Entry<K, V>> hashMap;
public LRUCache1(int cacheSize) {
MAX_CACHE_SIZE = cacheSize;
hashMap = new HashMap<K, Entry<K, V>>();
}
public void put(K key, V value) {
Entry entry = getEntry(key);
if (entry == null) {
if (hashMap.size() >= MAX_CACHE_SIZE) {
hashMap.remove(last.key);
removeLast();
}
entry = new Entry();
entry.key = key;
}
entry.value = value;
moveToFirst(entry);
hashMap.put(key, entry);
}
public V get(K key) {
Entry<K, V> entry = getEntry(key);
if (entry == null) return null;
moveToFirst(entry);
return entry.value;
}
public void remove(K key) {
Entry entry = getEntry(key);
if (entry != null) {
if (entry.pre != null) entry.pre.next = entry.next;
if (entry.next != null) entry.next.pre = entry.pre;
if (entry == first) first = entry.next;
if (entry == last) last = entry.pre;
}
hashMap.remove(key);
}
private void moveToFirst(Entry entry) {
if (entry == first) return;
if (entry.pre != null) entry.pre.next = entry.next;
if (entry.next != null) entry.next.pre = entry.pre;
if (entry == last) last = last.pre;
if (first == null || last == null) {
first = last = entry;
return;
}
entry.next = first;
first.pre = entry;
first = entry;
entry.pre = null;
}
private void removeLast() {
if (last != null) {
last = last.pre;
if (last == null) first = null;
else last.next = null;
}
}
private Entry<K, V> getEntry(K key) {
return hashMap.get(key);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
Entry entry = first;
while (entry != null) {
sb.append(String.format("%s:%s ", entry.key, entry.value));
entry = entry.next;
}
return sb.toString();
}
class Entry<K, V> {
public Entry pre;
public Entry next;
public K key;
public V value;
}
}Nach dem Login kopieren
FIFO-Implementierung von LinkedHashMap
FIFO Dies ist die Abkürzung für „First Input First Output“, was oft als „First In, First Out“ bezeichnet wird. Standardmäßig wird LinkedHashMap in gespeichert Die Reihenfolge der Hinzufügung. Wir müssen nur die Methode „removeEldestEntry“ umschreiben, um einen FIFO-Cache einfach zu implementieren. Die vereinfachte Version des Implementierungscodes lautet wie folgt:
Aufrufbeispiel
Testcode
final int cacheSize = 5;
LinkedHashMap<Integer, String> lru = new LinkedHashMap<Integer, String>() {
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
return size() > cacheSize;
}
};Nach dem Login kopieren
Laufergebnis
package cn.lzrabbit.structure.lru;
import cn.lzrabbit.ITest;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Created by liuzhao on 14-5-15.
*/
public class LRUCacheTest {
public static void main(String[] args) throws Exception {
System.out.println("start...");
lruCache1();
lruCache2();
lruCache3();
lruCache4();
System.out.println("over...");
}
static void lruCache1() {
System.out.println();
System.out.println("===========================LRU 链表实现===========================");
LRUCache1<Integer, String> lru = new LRUCache1(5);
lru.put(1, "11");
lru.put(2, "11");
lru.put(3, "11");
lru.put(4, "11");
lru.put(5, "11");
System.out.println(lru.toString());
lru.put(6, "66");
lru.get(2);
lru.put(7, "77");
lru.get(4);
System.out.println(lru.toString());
System.out.println();
}
static <T> void lruCache2() {
System.out.println();
System.out.println("===========================LRU LinkedHashMap(inheritance)实现===========================");
LRUCache2<Integer, String> lru = new LRUCache2(5);
lru.put(1, "11");
lru.put(2, "11");
lru.put(3, "11");
lru.put(4, "11");
lru.put(5, "11");
System.out.println(lru.toString());
lru.put(6, "66");
lru.get(2);
lru.put(7, "77");
lru.get(4);
System.out.println(lru.toString());
System.out.println();
}
static void lruCache3() {
System.out.println();
System.out.println("===========================LRU LinkedHashMap(delegation)实现===========================");
LRUCache3<Integer, String> lru = new LRUCache3(5);
lru.put(1, "11");
lru.put(2, "11");
lru.put(3, "11");
lru.put(4, "11");
lru.put(5, "11");
System.out.println(lru.toString());
lru.put(6, "66");
lru.get(2);
lru.put(7, "77");
lru.get(4);
System.out.println(lru.toString());
System.out.println();
}
static void lruCache4() {
System.out.println();
System.out.println("===========================FIFO LinkedHashMap默认实现===========================");
final int cacheSize = 5;
LinkedHashMap<Integer, String> lru = new LinkedHashMap<Integer, String>() {
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
return size() > cacheSize;
}
};
lru.put(1, "11");
lru.put(2, "11");
lru.put(3, "11");
lru.put(4, "11");
lru.put(5, "11");
System.out.println(lru.toString());
lru.put(6, "66");
lru.get(2);
lru.put(7, "77");
lru.get(4);
System.out.println(lru.toString());
System.out.println();
}
}Nach dem Login kopieren
Für weitere Java-Kenntnisse folgen Sie bitte der Spalte
Java Basic Tutorial.
Das obige ist der detaillierte Inhalt vonLRU-Cache-Implementierung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
