Verfügt Redis über eine geplante Löschfunktion?

Es gibt drei mögliche Antworten auf das Redis-Timeout-Löschen, die drei verschiedene Löschstrategien darstellen:

Geplantes Löschen: Erstellen Sie beim Festlegen der Ablaufzeit des Schlüssels einen Timer (Timer) und lassen Sie den Timer den Schlüssel sofort löschen, wenn die Ablaufzeit des Schlüssels erreicht ist.

Verzögertes Löschen: Lassen Sie den Schlüssel ablaufen, aber prüfen Sie jedes Mal, wenn Sie den Schlüssel aus dem Schlüsselraum erhalten, ob er abgelaufen ist. Wenn er nicht abgelaufen ist, kehren Sie zurück der Schlüssel.

Regelmäßiges Löschen: Von Zeit zu Zeit überprüft das Programm die Datenbank und löscht die abgelaufenen Schlüssel. Es liegt am Algorithmus, zu entscheiden, wie viele abgelaufene Schlüssel gelöscht und wie viele Datenbanken überprüft werden sollen.

Von diesen drei Strategien handelt es sich bei der ersten und dritten um aktive Löschstrategien, während es sich bei der zweiten um eine passive Löschstrategie handelt.

Geplantes Löschen:

Die Strategie zum geplanten Löschen ist am speicherschonendsten: Durch die Verwendung eines Timers kann die Strategie zum geplanten Löschen dies sicherstellen Abgelaufene Schlüssel werden so schnell wie möglich entfernt und der von abgelaufenen Schlüsseln belegte Speicher wird freigegeben.

Andererseits besteht der Nachteil der Strategie zum geplanten Löschen darin, dass sie die CPU-Zeit am wenigsten schont: Wenn viele abgelaufene Schlüssel vorhanden sind, kann das Löschen abgelaufener Schlüssel einen erheblichen Teil der CPU-Zeit in Anspruch nehmen. Wenn der Speicher nicht knapp, aber die CPU-Zeit sehr knapp ist, wirkt sich die Nutzung der CPU-Zeit zum Löschen abgelaufener Schlüssel, die für die aktuelle Aufgabe irrelevant sind, zweifellos auf die Antwortzeit und den Durchsatz des Servers aus.

Wenn beispielsweise eine große Anzahl von Befehlsanfragen auf die Verarbeitung durch den Server wartet und der Server derzeit nicht über genügend Arbeitsspeicher verfügt, sollte der Server die Verwendung von CPU-Zeit priorisieren, um die Befehlsanfragen des Clients zu verarbeiten Löschen abgelaufener Schlüssel oben.

Darüber hinaus erfordert die Erstellung eines Timers die Verwendung von Zeitereignissen im Redis-Server. Das aktuelle Zeitereignis ist als ungeordnete verknüpfte Liste implementiert. Große Mengen an zeitlichen Ereignissen können nicht effizient verarbeitet werden.

Daher ist es zum jetzigen Zeitpunkt nicht realistisch, dass der Server eine große Anzahl von Timern erstellt, um eine geplante Löschstrategie umzusetzen.

Verzögertes Löschen:

Die Strategie des verzögerten Löschens ist die CPU-zeitschonendste: Das Programm löscht den Schlüssel nur, wenn er entfernt wird Führen Sie eine Ablaufprüfung durch, die sicherstellt, dass das Löschen abgelaufener Schlüssel nur bei Bedarf erfolgt und das Löschziel auf die aktuell verarbeiteten Schlüssel beschränkt ist. Diese Strategie verbraucht keine CPU-Zeit für das Löschen anderer irrelevanter abgelaufener Schlüssel.

Der Nachteil der Lazy-Deletion-Strategie besteht darin, dass sie am wenigsten speicherschonend ist: Wenn ein Schlüssel abgelaufen ist und der Schlüssel noch in der Datenbank verbleibt, wird der abgelaufene Schlüssel nicht gelöscht. es wird belegt Der Speicher wird nicht freigegeben.

Wenn bei Verwendung der Lazy-Deletion-Strategie viele abgelaufene Schlüssel in der Datenbank vorhanden sind und auf diese abgelaufenen Schlüssel zufällig nicht zugegriffen wird, werden sie möglicherweise nie gelöscht (es sei denn, der Benutzer führt FLUSHDB manuell aus). Wir können diese Situation sogar als Speicherverlust betrachten – nutzlose Mülldaten belegen eine große Menge an Speicher, aber der Server gibt sie nicht von selbst frei. Dies ist definitiv ein Problem für den Redis-Server, dessen Betriebsstatus stark vom Speicher abhängt keine gute Nachricht.

Bei einigen zeitbezogenen Daten, wie z. B. Protokollen, ist der Zugriff darauf nach einem bestimmten Zeitpunkt stark eingeschränkt oder es gibt sogar keinen Zugriff mehr auf solche abgelaufenen Daten Benutzer sind der Meinung, dass der Server sie automatisch gelöscht hat, aber tatsächlich sind diese Schlüssel noch vorhanden und der von ihnen belegte Speicher wurde nicht freigegeben. Die Folgen müssen sehr schwerwiegend sein.

Regelmäßiges Löschen:

Aus der obigen Diskussion des geplanten Löschens und des verzögerten Löschens geht hervor, dass diese beiden Löschmethoden einzeln verwendet werden können. Alle sind offensichtlich Mängel:

· Das geplante Löschen beansprucht zu viel CPU-Zeit und beeinträchtigt die Reaktionszeit und den Durchsatz des Servers.

·Verzögertes Löschen verschwendet zu viel Speicher und riskiert Speicherlecks.

Die Strategie der periodischen Löschung ist eine Integration und ein Kompromiss der ersten beiden Strategien:

·Die Strategie der periodischen Löschung führt die Löschung abgelaufener Schlüssel von Zeit zu Zeit durch und begrenzt die Löschung Dauer und Häufigkeit des Vorgangs, um die Auswirkungen von Löschvorgängen auf die CPU-Zeit zu reduzieren.

·Darüber hinaus reduziert die regelmäßige Löschstrategie durch das regelmäßige Löschen abgelaufener Schlüssel effektiv die durch abgelaufene Schlüssel verursachte Speicherverschwendung.

Die Schwierigkeit der periodischen Löschstrategie besteht darin, die Dauer und Häufigkeit des Löschvorgangs zu bestimmen:

·Wenn der Löschvorgang zu häufig durchgeführt wird oder zu lange dauert, wird dies bei der periodischen Löschstrategie der Fall sein degenerieren in Die geplante Löschstrategie verbraucht beim Löschen abgelaufener Schlüssel zu viel CPU-Zeit.

·Wenn der Löschvorgang zu selten ausgeführt wird oder die Ausführungszeit zu kurz ist, ist die reguläre Löschstrategie dieselbe wie die verzögerte Löschstrategie, was zu einer Speicherverschwendung führt.

Die Strategie zum regelmäßigen Löschen abgelaufener Schlüssel wird durch die Funktion redis.c/activeExpireCycle implementiert. Immer wenn die Funktion redis.c/serverCron für den periodischen Betrieb des Redis-Servers ausgeführt wird, wird sie aufgerufen Zum angegebenen Zeitpunkt wird jede Datenbank auf dem Server mehrmals durchlaufen, die Ablaufzeit einiger Schlüssel wird zufällig aus dem Ablaufwörterbuch der Datenbank überprüft und die abgelaufenen Schlüssel werden gelöscht.

Der gesamte Prozess kann im Pseudocode wie folgt beschrieben werden:

#
默认每次检查的数据库数量
DEFAULT_DB_NUMBERS = 16
#
默认每个数据库检查的键数量
DEFAULT_KEY_NUMBERS = 20
#
全局变量，记录检查进度
current_db = 0
def activeExpireCycle():
    #
初始化要检查的数据库数量
    #
如果服务器的数据库数量比 DEFAULT_DB_NUMBERS
要小
    #
那么以服务器的数据库数量为准
    if server.dbnum < DEFAULT_DB_NUMBERS:
        db_numbers = server.dbnum
    else:
        db_numbers = DEFAULT_DB_NUMBERS
    #
遍历各个数据库
    for i in range(db_numbers):
        #
如果current_db
的值等于服务器的数据库数量
        #
这表示检查程序已经遍历了服务器的所有数据库一次
        #
将current_db
重置为0
，开始新的一轮遍历
        if current_db == server.dbnum:
            current_db = 0
        #
获取当前要处理的数据库
        redisDb = server.db[current_db]
        #
将数据库索引增1
，指向下一个要处理的数据库
        current_db += 1
        #
检查数据库键
        for j in range(DEFAULT_KEY_NUMBERS):
            #
如果数据库中没有一个键带有过期时间，那么跳过这个数据库
            if redisDb.expires.size() == 0: break
            #
随机获取一个带有过期时间的键
            key_with_ttl = redisDb.expires.get_random_key()
            #
检查键是否过期，如果过期就删除它
            if is_expired(key_with_ttl):
                delete_key(key_with_ttl)
            #
已达到时间上限，停止处理
            if reach_time_limit(): return

Der Arbeitsmodus der activeExpireCycle-Funktion kann wie folgt zusammengefasst werden:

·Jedes Mal, wenn die Funktion ausgeführt wird Ausgehend von einer bestimmten Anzahl von Datenbanken wird eine bestimmte Anzahl zufälliger Schlüssel zur Überprüfung entnommen und abgelaufene Schlüssel gelöscht.

·Die globale Variable current_db zeichnet den Fortschritt der aktuellen ActiveExpireCycle-Funktionsprüfung auf und beim nächsten Aufruf der ActiveExpireCycle-Funktion wird der vorherige Fortschritt verarbeitet. Wenn beispielsweise die aktuelle Funktion „activeExpireCycle“ beim Durchlaufen der Datenbank Nr. 10 zurückkehrt, wird bei der nächsten Ausführung der Funktion „activeExpireCycle“ ab Datenbank Nr. 11 nach abgelaufenen Schlüsseln gesucht und diese gelöscht.

·Während die Funktion „activeExpireCycle“ weiterhin ausgeführt wird, werden alle Datenbanken auf dem Server überprüft. Zu diesem Zeitpunkt setzt die Funktion die Variable „current_db“ auf 0 zurück und startet dann erneut eine neue Runde der Überprüfungsarbeit.

Weitere Informationen zu Redis finden Sie in der Spalte Tutorial zur Redis-Nutzung!

Das obige ist der detaillierte Inhalt vonVerfügt Redis über eine geplante Löschfunktion?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!