Vergleich verteilter, sich selbst erhöhender ID-Lösungen, die von Redis implementiert wurden

Bei der verteilten Anwendungsentwicklung ist die Generierung automatisch inkrementierender IDs eine häufige Anforderung. In einer eigenständigen Umgebung können Sie den Auto-Inkrement-Primärschlüssel der Datenbank verwenden, um die Auto-Inkrement-ID zu implementieren. In einer verteilten Umgebung führt die Verwendung von Auto-Inkrement-Primärschlüsseln jedoch zu Duplikaten Stellen Sie die Eindeutigkeit von Auto-Inkrement-IDs sicher.

Redis ist eine leistungsstarke In-Memory-Datenbank, die verteilte, sich selbst erhöhende ID-Lösungen implementieren kann. In diesem Artikel stellen wir drei gängige Redis-Lösungen zur verteilten selbsterhöhenden ID vor und vergleichen sie, um Entwicklern bei der Auswahl der Lösung zu helfen, die zu ihren Projekten passt.

Basierend auf dem Befehl redis incr

Redis stellt einen Befehl incr bereit, der den angegebenen Schlüssel erhöhen und den erhöhten Wert zurückgeben kann. Wenn Sie den Befehl incr zum Generieren einer Auto-Inkrement-ID verwenden, können Sie den Schlüssel auf eine feste Zeichenfolge festlegen und die Zeichenfolge bei jedem Vorgang erhöhen.

Der Hauptcode für die Verwendung von Redis zum Generieren eines verteilten automatisch inkrementierenden ID-Schemas lautet wie folgt:

from redis import StrictRedis

redis = StrictRedis(host='localhost', port=6379, db=0)

def get_next_id():
    return redis.incr('id_generator')

Da der Befehl incr von Redis eine atomare Operation ist, kann garantiert werden, dass die generierte ID eindeutig ist, wenn mehrere Clients darauf zugreifen gleichzeitig.

Die auf dem Befehl redis incr basierende Lösung ist sehr einfach, weist jedoch einen schwerwiegenden Fehler auf: Wenn der maximal verfügbare Wert von Redis erreicht ist (Standard ist 2 ^ 31-1), wird ein Fehler angezeigt zurückgegeben werden. Dies bedeutet, dass die ID nicht verfügbar ist, wenn der Dienst längere Zeit nach dem Online-Schalten des Systems nicht neu gestartet wird, was zu Datenverlust oder Datenunterbrechungen führen kann.

Basierend auf dem Lua-Skript des Redis-Skripts

Um das Problem zu vermeiden, dass die sich selbst erhöhende Redis-ID längere Zeit nicht verfügbar ist, können wir das Lua-Skript verwenden, um den Bereich der sich selbst erhöhenden ID zu steuern. Lua-Skripte können mehrere Vorgänge in einem atomaren Vorgang abschließen, was es ermöglicht, den Bereich anzugeben, in dem die Auto-Inkrement-ID basierend auf den Geschäftsanforderungen generiert werden soll, wenn eine Auto-Inkrement-ID generiert wird, anstatt sie ständig weiter zu erhöhen .

Das Folgende ist der Code für das verteilte Auto-Inkrement-ID-Schema von Redis, das basierend auf dem Lua-Skript implementiert wurde:

from redis import StrictRedis

redis = StrictRedis(host='localhost', port=6379, db=0)

SCRIPT = """
local name = KEYS[1]
local start = tonumber(ARGV[1])
local stop = tonumber(ARGV[2])
if redis.call('exists', name) == 0 then
    redis.call('set', name, start)
    return tonumber(start)
end
local id = redis.call('incr', name)
if id < stop then
    return tonumber(id)
else
    redis.call('set', name, start)
    return tonumber(start)
end
"""

def get_next_id(start, stop):
    result = redis.eval(script=SCRIPT, keys=['id_generator'], args=[start, stop])
    return result

In diesem Lua-Skript definieren wir zwei Parameter, Start und Stopp, um den Bereich der automatischen Inkrement-ID-Generierung zu steuern. Wenn der Schlüssel id_generator in Redis nicht vorhanden ist, initialisieren Sie ihn zum Starten und kehren Sie zum Start zurück. Verwenden Sie andernfalls den Befehl incr von Redis, um den id_generator zu erhöhen und festzustellen, ob der erhöhte Wert den Stoppwert überschreitet. Wenn der Wert überschritten wird, setzen Sie den Wert von id_generator auf start zurück und kehren Sie zu start zurück. Andernfalls geben Sie die neu generierte ID zurück.

Diese Lua-Skript-basierte Implementierung kann den Bereich der automatisch inkrementierten ID-Generierung flexibel steuern, ist jedoch komplexer zu implementieren. Sie müssen den Redis-Eval-Befehl verwenden, um das Lua-Skript auszuführen und Parameter zu übergeben.

Basierend auf Redis Redlock

Redlock ist eine von Redis bereitgestellte verteilte Sperrlösung, die sicherstellen kann, dass in einer verteilten Umgebung nur ein Client gleichzeitig auf dieselbe Ressource zugreifen kann. Wir können Redlock verwenden, um ein verteiltes Auto-Inkrement-ID-Schema zu implementieren, um sicherzustellen, dass die generierte Auto-Inkrement-ID eindeutig ist.

Der Hauptcode für die Verwendung von Redlock zur Implementierung des verteilten, sich selbst erhöhenden ID-Schemas lautet wie folgt:

from redis import StrictRedis
from redlock import Redlock

redis = StrictRedis(host='localhost', port=6379, db=0)
redlock = Redlock([{"host": "localhost", "port": 6379, "db": 0}], retry_times=3)

def get_next_id():
    with redlock.lock('id_lock', 1000):
        return redis.incr('id_generator')

Durch die Verwendung von Redlock zur Implementierung des verteilten, sich selbst erhöhenden ID-Schemas können wir das Problem der doppelten ID-Generierung vermeiden, wenn mehrere Clients darauf zugreifen es gleichzeitig und kann beim Generieren einer automatisch inkrementierenden ID gesperrt werden, um Thread-Sicherheitsproblemen vorzubeugen.

Da der Sperrvorgang jedoch viel Zeit und Ressourcen verbraucht, kann die Leistung von Redlock in Szenarien mit hoher Parallelität abnehmen.

Vergleichende Analyse

Drei Redis-Implementierungen verteilter selbsterhöhender ID-Lösungen haben jeweils ihre eigenen Vor- und Nachteile:

1. Basierend auf dem Befehl redis incr

Vorteile: Einfach zu implementieren, bequem und schnell .

Nachteile: Die ID erhöht sich von selbst weiter und es können Probleme wie Nichtverfügbarkeit der ID, Datenverlust oder Datenunterbrechung auftreten.

Anwendbare Szenarien: einfache Geschäftsszenarien, die keine hohe Kontinuität der Daten-ID erfordern.

2. Basierend auf dem Redis-Skript Lua-Skript

Vorteile: Der Generierungsbereich der sich selbst erhöhenden ID kann flexibel gesteuert werden, um die Kontinuität der Daten sicherzustellen.

Nachteile: Die Implementierung ist komplex und Sie müssen den Befehl Redis eval verwenden, um das Lua-Skript auszuführen und Parameter zu übergeben.

Anwendbare Szenarien: Szenarien mit strengen Anforderungen an die Daten-ID-Kontinuität und Geschäftslogik, wie z. B. E-Commerce, Finanzen usw.

3. Basierend auf Redis Redlock

Vorteile: Der Sperrvorgang gewährleistet die Thread-Sicherheit und vermeidet das Problem der wiederholten Datengenerierung.

Nachteile: Da Sperrvorgänge viel Zeit und Ressourcen verbrauchen, kann die Leistung in Szenarien mit hoher Parallelität abnehmen.

Anwendbare Szenarien: Szenarien mit hoher Parallelität, Verteilung und hohen Anforderungen an die Kontinuität von Daten-IDs.

Fazit

Basierend auf der obigen Vergleichsanalyse können wir folgende Schlussfolgerung ziehen:

1. Die beiden auf dem Befehl redis incr und der auf redis Redlock basierenden Lösungen haben einen engen Anwendungsbereich und sind nicht für alle Szenarien geeignet .
2. Die auf dem Redis-Skript basierende Lua-Skriptlösung kann den Generierungsbereich automatisch inkrementierter IDs flexibel steuern und eignet sich für Szenarien, die eine Daten-ID-Kontinuität und hohe Anforderungen an die Geschäftslogik erfordern.

Daher müssen Sie bei der Auswahl von Redis zur Implementierung einer verteilten, sich selbst erhöhenden ID-Lösung die spezifischen Anforderungen des Geschäftsszenarios berücksichtigen und eine geeignete Lösung auswählen.

Das obige ist der detaillierte Inhalt vonVergleich verteilter, sich selbst erhöhender ID-Lösungen, die von Redis implementiert wurden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!