Um den lokalen Java-Cache zu implementieren, beginnen Sie mit diesen Punkten

Caching, ich glaube, jeder kennt es. Im Projekt ist Caching definitiv unverzichtbar. Es gibt viele Caching-Tools auf dem Markt, wie zum Beispiel Redis, Guava Cache oder EHcache.

Ich denke, jeder muss mit diesen Tools sehr vertraut sein, daher werden wir heute nicht darüber sprechen, wie man lokales Caching implementiert. In Bezug auf die oben genannten Tools ist Bruder Pingtou der Ansicht, dass wir von den folgenden drei Aspekten ausgehen sollten, um einen besseren lokalen Cache zu erreichen.

1. Auswahl der Speichersammlungen

Um lokales Caching zu implementieren, muss der Speichercontainer eine Datenstruktur in Form eines Schlüssels/Werts sein unsere häufig verwendete Kartensammlung. In Map stehen uns HashMap, Hashtable und ConcurrentHashMap zur Auswahl. Wenn wir keine Datensicherheitsprobleme bei hoher Parallelität berücksichtigen, können wir HashMap wählen ConcurrentHashMap-Sammlung, wir bevorzugen jedoch ConcurrentHashMap, da die Leistung von ConcurrentHashMap besser ist als die von Hashtable.

2. Verarbeitung abgelaufener Caches

Da der Cache direkt im Speicher gespeichert wird, wird der Speicher stark belegt, wenn wir den abgelaufenen Cache nicht verarbeiten Anzahl ungültiger Caches, was nicht das ist, was wir wollen. Ja, also müssen wir diese ungültigen Caches bereinigen. Die Verarbeitung abgelaufener Caches kann mithilfe der Redis-Strategie implementiert werden. Redis verwendet eine Strategie für regelmäßiges Löschen und verzögerte Eliminierung.

Strategie zum periodischen Löschen

Die Strategie zum periodischen Löschen besteht darin, abgelaufene Caches in regelmäßigen Abständen zu erkennen und zu löschen. Der Vorteil dieser Strategie besteht darin, dass abgelaufene Caches gelöscht werden. Es gibt auch Nachteile. Abgelaufene Caches werden möglicherweise nicht rechtzeitig gelöscht. Ein weiterer Nachteil besteht darin, dass jede Erkennung den Cup stark belastet. .

Lazy-Eliminierung-Strategie

Die Lazy-Eliminierung-Strategie besteht darin, bei der Verwendung des Caches zunächst festzustellen, ob der Cache abgelaufen ist. Wenn er abläuft, löschen Sie ihn und geben Sie ihn leer zurück. Der Vorteil dieser Strategie besteht darin, dass bei der Suche nur festgestellt werden kann, ob sie abgelaufen ist, was weniger Auswirkungen auf CUP hat. Gleichzeitig weist diese Strategie einen schwerwiegenden Nachteil auf. Wenn eine große Anzahl von Caches gespeichert wird, werden diese Caches nicht verwendet und sind abgelaufen. Diese ungültigen Caches belegen einen großen Teil Ihres Speicherplatzes. und schließlich dazu führen, dass der Serverspeicher überläuft.

Wir haben uns kurz die beiden Ablaufcache-Verarbeitungsstrategien von Redis angesehen. Jede Strategie hat ihre eigenen Vor- und Nachteile. Daher können wir bei der Anwendung die beiden Strategien kombinieren, und der kombinierte Effekt ist immer noch sehr ideal.

3. Cache-Eliminationsstrategie

Cache-Eliminierung sollte von der Cache-Eliminierung unterschieden werden, wenn die Anzahl unserer Caches die von uns angegebene Anzahl erreicht. Schließlich ist unser Gedächtnis nicht unendlich. Wenn wir weiterhin Caches hinzufügen müssen, müssen wir einige Caches in den vorhandenen Caches gemäß einer bestimmten Strategie entfernen, um Platz für die neu hinzugefügten Caches zu schaffen. Lassen Sie uns einige häufig verwendete Strategien zur Cache-Beseitigung kennenlernen.

First-In-First-Out-Richtlinie

Wenn der Cache-Speicherplatz nicht ausreicht, werden die Daten, die zuerst in den Cache gelangen, zuerst gelöscht, um neuen Speicherplatz für die Aufnahme neuer Daten freizugeben Daten. Daten. Diese Strategie vergleicht hauptsächlich die Erstellungszeit zwischengespeicherter Elemente. In einigen Szenarien, die eine relativ hohe Dateneffektivität erfordern, kann diese Art von Strategie in Betracht gezogen werden, um sicherzustellen, dass die neuesten Daten verfügbar sind.

Am wenigsten genutzte Strategie

Unabhängig davon, ob sie abgelaufen ist oder nicht, werden anhand der Häufigkeit, mit der das Element verwendet wurde, Elemente gelöscht, die seltener verwendet wurden um Platz freizugeben. Diese Strategie vergleicht hauptsächlich die HitCount (Anzahl der Treffer) von Elementen. Diese Art von Strategie kann in Szenarien ausgewählt werden, in denen die Gültigkeit von Hochfrequenzdaten sichergestellt ist.

Strategie „Am längsten verwendet“

Unabhängig davon, ob es abgelaufen ist oder nicht, löschen Sie basierend auf dem zuletzt verwendeten Zeitstempel des Elements das Element mit dem am weitesten entfernten verwendeten Zeitstempel Platz freigeben. Diese Strategie vergleicht hauptsächlich die Zeit, zu der der Cache zuletzt von get verwendet wurde. Es ist besser in Hot-Data-Szenarien anwendbar und der Sicherstellung der Gültigkeit von Hot-Data wird Priorität eingeräumt.

Strategie zur zufälligen Eliminierung

Löschen Sie einen Cache nach dem Zufallsprinzip, unabhängig davon, ob er abgelaufen ist oder nicht. Wenn keine Anforderungen für zwischengespeicherte Daten bestehen, können Sie die Verwendung dieser Strategie in Betracht ziehen.

Nicht-Eliminierungsstrategie

Wenn der Cache den angegebenen Wert erreicht, wird kein Cache gelöscht, aber es wird kein neuer Cache hinzugefügt. Es können keine weiteren Caches hinzugefügt werden bis ein Cache gelöscht wird.

Die oben genannten drei Punkte müssen bei der Implementierung eines lokalen Caches berücksichtigt werden. Nachdem wir dies gelesen haben, sollten wir wissen, wie man einen lokalen Cache implementiert.

Lokalen Cache implementieren

In dieser Demo verwenden wir ConcurrentHashMap als Speichersammlung, damit wir die Sicherheit des Caches auch in Situationen mit hoher Parallelität gewährleisten können. Für die Verarbeitung abgelaufener Caches habe ich hier nur die geplante Löschstrategie verwendet und nicht die Strategie für geplantes Löschen + verzögerte Eliminierung. Sie können es selbst ausprobieren und diese beiden Strategien für die Verarbeitung abgelaufener Caches verwenden. Was die Cache-Räumung angeht, verfolge ich hier eine Least-Use-Strategie. Okay, da wir nun die technische Auswahl kennen, werfen wir einen Blick auf die Code-Implementierung.

Cache-Objektklasse

public class Cache implements Comparable<Cache>{
    // 键
    private Object key;
    // 缓存值
    private Object value;
    // 最后一次访问时间
    private long accessTime;
    // 创建时间
    private long writeTime;
    // 存活时间
    private long expireTime;
    // 命中次数
    private Integer hitCount;
    ...getter/setter()...

Cache hinzufügen

/**
 * 添加缓存
 *
 * @param key
 * @param value
 */
public void put(K key, V value,long expire) {
    checkNotNull(key);
    checkNotNull(value);
    // 当缓存存在时，更新缓存
    if (concurrentHashMap.containsKey(key)){
        Cache cache = concurrentHashMap.get(key);
        cache.setHitCount(cache.getHitCount()+1);
        cache.setWriteTime(System.currentTimeMillis());
        cache.setAccessTime(System.currentTimeMillis());
        cache.setExpireTime(expire);
        cache.setValue(value);
        return;
    }
    // 已经达到最大缓存
    if (isFull()) {
        Object kickedKey = getKickedKey();
        if (kickedKey !=null){
            // 移除最少使用的缓存
            concurrentHashMap.remove(kickedKey);
        }else {
            return;
        }
    }
    Cache cache = new Cache();
    cache.setKey(key);
    cache.setValue(value);
    cache.setWriteTime(System.currentTimeMillis());
    cache.setAccessTime(System.currentTimeMillis());
    cache.setHitCount(1);
    cache.setExpireTime(expire);
    concurrentHashMap.put(key, cache);
}

Cache abrufen

/**
 * 获取缓存
 *
 * @param key
 * @return
 */
public Object get(K key) {
    checkNotNull(key);
    if (concurrentHashMap.isEmpty()) return null;
    if (!concurrentHashMap.containsKey(key)) return null;
    Cache cache = concurrentHashMap.get(key);
    if (cache == null) return null;
    cache.setHitCount(cache.getHitCount()+1);
    cache.setAccessTime(System.currentTimeMillis());
    return cache.getValue();
}

Den am wenigsten genutzten Cache abrufen

/**
     * 获取最少使用的缓存
     * @return
     */
    private Object getKickedKey() {
        Cache min = Collections.min(concurrentHashMap.values());
        return min.getKey();
    }

Abgelaufene Cache-Erkennungsmethode

/**
 * 处理过期缓存
 */
class TimeoutTimerThread implements Runnable {
    public void run() {
        while (true) {
            try {
                TimeUnit.SECONDS.sleep(60);
                expireCache();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 创建多久后，缓存失效
     *
     * @throws Exception
     */
    private void expireCache() throws Exception {
        System.out.println("检测缓存是否过期缓存");
        for (Object key : concurrentHashMap.keySet()) {
            Cache cache = concurrentHashMap.get(key);
            long timoutTime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime()
                    - cache.getWriteTime());
            if (cache.getExpireTime() > timoutTime) {
                continue;
            }
            System.out.println(" 清除过期缓存 ： " + key);
            //清除过期缓存
            concurrentHashMap.remove(key);
        }
    }
}

Das obige ist der detaillierte Inhalt vonUm den lokalen Java-Cache zu implementieren, beginnen Sie mit diesen Punkten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!