Detaillierte Erläuterung der verteilten Sperrimplementierung in Redis

Mit der rasanten Entwicklung des mobilen Internets und dem explosionsartigen Wachstum des Datenvolumens erfreuen sich verteilte Systeme immer größerer Beliebtheit. In verteilten Systemen tritt das Problem gleichzeitiger Vorgänge immer stärker in den Vordergrund. Wenn mehrere Threads gleichzeitig gemeinsam genutzte Ressourcen anfordern, müssen diese Ressourcen gesperrt werden, um die Datenkonsistenz sicherzustellen. Verteilte Sperren sind eine der effektivsten Lösungen für die Implementierung gleichzeitiger Vorgänge in verteilten Systemen. In diesem Artikel wird detailliert beschrieben, wie Sie Redis zur Implementierung verteilter Sperren verwenden.

1. Redis-Grundlagen

Redis ist ein speicherbasiertes Schlüsselwertspeichersystem, das in verteilten Systemen weit verbreitet ist. Als leistungsstarke NoSQL-Datenbank hat Redis aufgrund seiner effizienten Lese- und Schreibleistung und seiner umfangreichen Datenstrukturen große Aufmerksamkeit erhalten. Redis kann verteilten Speicher basierend auf mehreren Maschinen implementieren und unterstützt die folgenden Datenstrukturen:

• String
• Hash
• List
• Set
• Ordered Set (Sorted Set)

Die Operationen von Redis basieren auf diesen Datenstrukturen Um verteilte Sperren zu implementieren, muss eine Funktion von Redis verwendet werden: SETNX (SET if Not eXists), das heißt, wenn der angegebene Schlüssel nicht vorhanden ist, kann der Schlüsselwert festgelegt werden. Wenn der Schlüssel bereits vorhanden ist, gibt der SETNX-Vorgang einen Fehler zurück.

2. Die Idee, verteilte Sperren zu implementieren

Um verteilte Sperren zu implementieren, müssen Sie zunächst das Ziel klären:

• Wenn in einer verteilten Umgebung mehrere Threads gleichzeitig dieselbe Ressource anfordern, ist dies erforderlich um sicherzustellen, dass nur ein Thread die Sperre erhalten kann.
• Wenn ein Thread die Sperre erworben hat, müssen andere Threads warten, bis die Sperre aufgehoben wird.

Um die oben genannten Ziele zu erreichen, können die folgenden Ideen übernommen werden:

• Verwenden Sie den SETNX-Befehl von Redis, um einen neuen Schlüssel als Identifikation des Schlosses zu erstellen.
• Wenn der SETNX-Befehl erfolgreich zurückgegeben wird, bedeutet dies, dass der aktuelle Thread die Sperre erhalten hat.
• Stellen Sie die Ablaufzeit von Schlüsseln ein, um Deadlock-Situationen zu vermeiden.
• Wenn ein Thread seine Aufgabe abschließt, wird die Sperre aufgehoben, d. h. der Schlüssel wird gelöscht.

3. Beispiel für einen Implementierungscode

Erstellen Sie zunächst eine Redis-Verbindung:

import redis conn = redis.Redis(host='localhost', port=6379, db=0)

Dann definieren Sie die Funktionen zum Erfassen und Freigeben von Sperren:

def acquire_lock(conn, lockname, acquire_timeout=10, lock_timeout=10): identifier = str(uuid.uuid4()) lockname = "lock:" + lockname end = time.time() + acquire_timeout while time.time() < end: if conn.setnx(lockname, identifier): conn.expire(lockname, lock_timeout) return identifier elif not conn.ttl(lockname): conn.expire(lockname, lock_timeout) time.sleep(0.001) return False def release_lock(conn, lockname, identifier): pipe = conn.pipeline(True) lockname = "lock:" + lockname while True: try: pipe.watch(lockname) if pipe.get(lockname) == identifier: pipe.multi() pipe.delete(lockname) pipe.execute() return True pipe.unwatch() break except redis.exceptions.WatchError: pass return False

Unter diesen wird die Funktion „acquire_lock“ zum Erlangen der Sperre und des Parameters verwendet Die Beschreibung lautet wie folgt:

• conn: Redis-Verbindung.
• lockname: Der Name des Schlosses.
• acquire_timeout: Das Zeitlimit beim Erwerb der Sperre, der Standardwert beträgt 10 Sekunden.
• lock_timeout: Die Ablaufzeit der Sperre, der Standardwert beträgt 10 Sekunden.

Diese Funktion generiert zunächst eine zufällige Kennung, versucht dann alle 0,001 Sekunden, die Sperre zu erhalten und legt die Ablaufzeit fest. Wenn die Sperre nicht innerhalb des angegebenen Timeouts erworben wird, wird False zurückgegeben. Die Funktion

release_lock wird verwendet, um die Sperre aufzuheben. Die Parameterbeschreibung lautet wie folgt:

• conn: Redis-Verbindung.
• lockname: Der Name des Schlosses.
• Identifikator: Der beim Erwerb der Sperre zurückgegebene Identifikator.

Diese Funktion verwendet zunächst den WATCH-Befehl, um die Sperre zu überwachen. Wenn der Wert der Sperre mit der Kennung übereinstimmt, verwendet sie den MULTI-Befehl, um die Sperre zu löschen und den Vorgang auszuführen. Andernfalls beenden Sie die Überwachung und geben „False“ zurück.

Verwenden Sie abschließend die Funktionen „acquire_lock“ und „release_lock“, um die verteilte Sperrfunktion zu implementieren. Der Beispielcode lautet wie folgt:

import time import uuid def do_task(): print("Task started...") time.sleep(5) print("Task finished") def main(): lockname = "mylock" identifier = acquire_lock(conn, lockname) if not identifier: print("Failed to obtain lock") return try: do_task() finally: release_lock(conn, lockname, identifier) if __name__ == '__main__': main()

In diesem Beispielcode wird die Funktion „acquire_lock“ verwendet, um die Sperre zu erhalten, und die Funktion „release_lock“ wird aufgerufen, um die Sperre nach der Ausführung der Aufgabe aufzuheben.

4. Zusammenfassung

Distributed Lock ist eine in verteilten Systemen weit verbreitete Technologie, die das Problem der Datenkonsistenz bei gleichzeitigen Vorgängen effektiv lösen kann. In diesem Artikel stellen wir detailliert vor, wie Sie Redis zum Implementieren verteilter Sperren verwenden. Mithilfe der SETNX-Befehls- und Ablaufzeiteinstellungen sowie der WATCH- und MULTI-Befehle können Sie die verteilte Sperrfunktion implementieren.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der verteilten Sperrimplementierung in Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!