Caching ist normalerweise eine der am häufigsten verwendeten Techniken in der Entwicklung. Allerdings verwenden viele Leute Caches nicht gern, da sie in manchen Fällen ernsthafte Probleme verursachen können, wie z. B. Cache-Lawine, Cache-Penetration, Cache-Zusammenbruch und Cache-Split-Brain.
Ich bin in meinen eigenen Projekten auf diese Probleme gestoßen und habe sie später mit Redis gelöst. Hier möchte ich meine Erfahrungen mit Redis zur Lösung dieser Probleme mit Ihnen teilen.
1. Cache-Lawine
Cache-Lawine bezieht sich auf eine große Anzahl von Cache-Fehlern, die innerhalb eines bestimmten Zeitraums auftreten und dazu führen, dass alle Anforderungen Daten aus der Datenbank abrufen, was zu einer übermäßigen Belastung der Datenbank oder sogar zu Ausfallzeiten führt. Dieses Problem kann gelöst werden, indem Redis für eine spezielle Verarbeitung verwendet wird.
Das Folgende ist der Java-Programmcode:
public Object get(String key) {
Object result = cache.get(key);
if (result == null) {
synchronized (this) {
result = cache.get(key);
if (result == null) {
// 从数据库中获取数据
result = getDataFromDatabase(key);
cache.put(key, result, expireTime);
}
}
}
return result;
}
Im obigen Code verwenden wir eine doppelte Beurteilung, um eine Cache-Lawine zu vermeiden. Wir holen uns zuerst die Daten aus dem Cache, und wenn wir die Daten bekommen, geben wir sie direkt zurück. Wenn die Daten nicht abgerufen werden, sperren Sie sie. Rufen Sie die Daten erneut aus dem Cache ab. Wenn Sie die Daten immer noch nicht erhalten, rufen Sie die Daten aus der Datenbank ab, legen Sie die Daten im Cache ab und legen Sie die Ablaufzeit fest.
2. Cache-Penetration
Unter Cache-Penetration versteht man den Zugriff auf einen nicht vorhandenen Schlüssel. Es befinden sich keine Daten im Cache und bei jeder Anforderung wird auf die Datenbank zugegriffen, was zu übermäßigem Druck auf die Datenbank führt. Dieses Problem kann gelöst werden, indem vor der Abfrage des Caches eine spezielle Verarbeitung durchgeführt wird.
Das Folgende ist der Java-Programmcode:
public Object get(String key) {
Object result = cache.get(key);
if (result == null) {
synchronized (this) {
result = cache.get(key);
if (result == null) {
// 查询数据库
result = getDataFromDatabase(key);
if (result == null) {
// 如果查询不到数据，则把空值放到缓存中，但设置较短的过期时间
cache.put(key, "", 60);
} else {
// 如果查询到了数据，就把数据放到缓存中
cache.put(key, result, expireTime);
}
}
}
}
return result;
}
Im obigen Code rufen wir zunächst die Daten aus dem Cache ab. Wenn wir die Daten erhalten, geben wir sie direkt zurück. Andernfalls sperren wir es und holen die Daten erneut aus dem Cache. Wenn wir die Daten immer noch nicht erhalten, holen wir uns die Daten aus der Datenbank. Wenn die Daten nicht abgefragt werden können, legen wir einen leeren String in den Cache und legen eine kurze Ablaufzeit fest. Wenn die Daten abgefragt werden, werden die Daten im Cache abgelegt.
3. Cache-Aufschlüsselung
Cache-Aufschlüsselung bedeutet, dass die Daten, die dem zwischengespeicherten Schlüssel im Cache entsprechen, gelöscht werden oder ablaufen. Dann, bevor der Schlüssel erneut in den Cache geladen wird, werden fortgesetzte Anforderungen direkt an die Datenbank weitergeleitet, was zu einer übermäßigen Belastung der Datenbank und sogar zu Ausfallzeiten führt. Dieses Problem kann durch Sperren beim Neuladen der Daten gelöst werden.
Das Folgende ist der Java-Programmcode:
public Object get(String key) {
Object result = cache.get(key);
if (result == null) {
synchronized (this) {
result = cache.get(key);
if (result == null) {
// 从数据库中获取数据
result = getDataFromDatabase(key);
if (result == null) {
// 如果查询不到数据，则把空值放到缓存中，并设置较短的过期Zeit, Cache-Löcher zu verhindern.
cache.put(key, "", 60);
} else {
// 如果查询到了数据，就把数据放到缓存中，并设置过期时间
cache.put(key, result, expireTime);
}
}
}
}
return result;
}
Im obigen Code rufen wir zunächst die Daten aus dem Puffer ab, und wenn wir die Daten erhalten, geben wir sie direkt zurück. Andernfalls sperren wir und holen die Daten erneut aus dem Puffer. Wenn die Daten immer noch nicht abgerufen werden, holen wir sie aus der Datenbank. Wenn die Daten nicht vorhanden sind, legen wir trotzdem eine leere Zeichenfolge in den Puffer, um Probleme mit Pufferlöchern zu vermeiden. Wenn die Daten abgefragt werden, legen wir die Daten in den Cache und legen die Ablaufzeit fest.
4. Cache-Split-Brain
Cache-Split-Brain bezieht sich darauf, dass ein Schlüssel im Cache mehrerer Knoten vorhanden ist, der Cache eines Knotens jedoch abgelaufen ist und andere Knoten keine Zeit hatten, ihn zu aktualisieren, was zu Dateninkonsistenzen führt. Dieses Problem kann durch den Redis-Cluster gelöst werden.
Der Redis-Cluster unterteilt eine große Redis-Datenbank in mehrere kleine Redis-Datenbanken. Jede kleine Redis-Datenbank ist für einen Teil der Daten verantwortlich. Wenn Daten aktualisiert werden, müssen sie nur in der entsprechenden kleinen Redis-Datenbank aktualisiert werden, wodurch die Notwendigkeit entfällt Gleichzeitige Updates. Problem beim Aktualisieren mehrerer Knoten.
Zusammenfassen
Die Verwendung des Redis-Cache kann die Leistung und den Durchsatz des Systems verbessern, aber eine übermäßige Nutzung kann auch zu einigen schwerwiegenden Problemen führen, wie z. B. Cache-Lawine, Cache-Penetration, Cache-Aufschlüsselung und Cache-Split-Brain. Bei der Verwendung des Redis-Cache müssen wir diese Probleme sorgfältig prüfen und entsprechende Maßnahmen ergreifen, um diese Probleme zu vermeiden, z. B. doppelte Beurteilung und Sperrung, um Cache-Lawine und Cache-Ausfälle zu beheben, und leere Zeichenfolgen in den Cache einfügen, um ein Eindringen in den Cache zu verhindern Verwenden Sie den Redis-Cluster, um das Cache-Split-Brain-Problem zu lösen.