Comparaison des solutions d'identification distribuées à auto-augmentation implémentées par Redis

Dans le développement d'applications distribuées, la génération d'identifiants à incrémentation automatique est une exigence courante. Dans un environnement autonome, vous pouvez utiliser la clé primaire d'incrémentation automatique de la base de données pour implémenter l'ID d'incrémentation automatique. Cependant, dans un environnement distribué, l'utilisation de clés primaires d'incrémentation automatique entraînera une duplication. Par conséquent, d'autres solutions doivent être utilisées. garantir l’unicité des identifiants à incrémentation automatique.

Redis est une base de données en mémoire hautes performances qui peut implémenter des solutions d'identification distribuées à auto-augmentation. Dans cet article, nous présenterons trois solutions d'identification distribuées à croissance automatique Redis courantes et les comparerons pour aider les développeurs à choisir la solution qui convient à leurs projets.

Basé sur la commande redis incr

Redis fournit une commande incr qui peut incrémenter la clé spécifiée et renvoyer la valeur incrémentée. Lorsque vous utilisez la commande incr pour générer un ID d'incrémentation automatique, vous pouvez définir la clé sur une chaîne fixe et incrémenter la chaîne à chaque opération.

Le code principal permettant d'utiliser Redis pour générer un schéma d'identification distribué à incrémentation automatique est le suivant :

from redis import StrictRedis

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

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

Étant donné que la commande incr de Redis est une opération atomique, il peut être garanti que l'ID généré est unique lorsque plusieurs clients y accèdent. en même temps.

La solution basée sur la commande redis incr est très simple, mais elle présente un défaut fatal : l'ID continuera d'augmenter lorsque la valeur maximale disponible de Redis est atteinte (la valeur par défaut est 2^31-1), une erreur sera générée. est revenu. Cela signifie que si le service n'est pas redémarré pendant une longue période après la mise en ligne du système, l'ID sera indisponible, ce qui peut entraîner une perte ou une discontinuité des données.

Basé sur le script Lua du script Redis

Afin d'éviter le problème de l'indisponibilité prolongée de l'ID auto-augmentation Redis, nous pouvons utiliser le script Lua pour contrôler la plage de l'ID auto-augmentation. Les scripts Lua peuvent effectuer plusieurs opérations en une seule opération atomique, ce qui permet de spécifier la plage dans laquelle l'ID d'auto-incrémentation doit être généré en fonction des exigences de l'entreprise lors de la génération d'un ID d'auto-incrémentation, plutôt que de continuer à l'incrémenter tout le temps. .

Ce qui suit est le code du schéma d'identification à incrémentation automatique distribué Redis implémenté sur la base du script Lua :

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

Dans ce script Lua, nous définissons deux paramètres, start et stop, pour contrôler la plage de génération d'ID à incrémentation automatique. Si la clé id_generator n'existe pas dans Redis, initialisez-la pour démarrer et revenez au démarrage ; sinon, utilisez la commande incr de Redis pour incrémenter l'id_generator et déterminer si la valeur incrémentée dépasse la valeur d'arrêt. S'il dépasse, réinitialisez la valeur de id_generator pour démarrer et revenez à démarrer sinon, renvoyez le nouvel ID généré.

Cette implémentation basée sur un script Lua peut contrôler de manière flexible la plage de génération des identifiants auto-incrémentés, mais elle est plus compliquée à implémenter. Vous devez utiliser la commande Redis eval pour exécuter le script Lua et transmettre les paramètres.

Basé sur redis Redlock

Redlock est une solution de verrouillage distribué fournie par Redis, qui peut garantir qu'un seul client à la fois peut accéder à la même ressource dans un environnement distribué. Nous pouvons utiliser Redlock pour implémenter un schéma d'ID d'auto-incrémentation distribué afin de garantir que l'ID d'auto-incrémentation généré est unique.

Le code principal d'utilisation de Redlock pour implémenter le schéma d'identification distribué à auto-augmentation est le suivant :

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')

En utilisant Redlock pour implémenter le schéma d'identification distribué à auto-augmentation, nous pouvons éviter le problème de génération d'ID en double lorsque plusieurs clients accèdent en même temps, et peut se verrouiller lors de la génération d'un ID à incrémentation automatique pour éviter les problèmes de sécurité des threads.

Cependant, étant donné que l'opération de verrouillage consomme beaucoup de temps et de ressources, les performances de Redlock peuvent diminuer dans les scénarios de concurrence élevée.

Analyse comparative

Trois solutions d'identification distribuées à auto-augmentation Redis ont chacune leurs propres avantages et inconvénients. Analysons leur comparaison :

1. Basée sur la commande redis incr

Avantages : Simple à mettre en œuvre, pratique et rapide.

Inconvénients : l'ID continuera d'augmenter d'eux-mêmes et des problèmes tels que l'indisponibilité de l'ID, la perte de données ou la discontinuité des données peuvent survenir.

Scénarios applicables : scénarios commerciaux simples, qui ne nécessitent pas une grande continuité d'identification des données.

2. Basé sur le script Redis Lua script

Avantages : La plage de génération d'ID auto-augmentation peut être contrôlée de manière flexible pour assurer la continuité des données.

Inconvénients : L'implémentation est complexe et vous devez utiliser la commande Redis eval pour exécuter le script Lua et transmettre les paramètres.

Scénarios applicables : scénarios avec des exigences strictes en matière de continuité de l'identification des données et de logique métier, tels que le commerce électronique, la finance, etc.

3. Basé sur redis Redlock

Avantages : L'opération de verrouillage garantit la sécurité des threads et évite le problème de la génération répétée de données.

Inconvénients : étant donné que les opérations de verrouillage consomment beaucoup de temps et de ressources, les performances peuvent diminuer dans les scénarios à forte concurrence.

Scénarios applicables : scénarios avec une simultanéité, une distribution et des exigences élevées pour la continuité des identifiants de données.

Conclusion

Sur la base de l'analyse comparative ci-dessus, nous pouvons tirer la conclusion suivante :

1. Les deux solutions basées sur la commande redis incr et la solution basée sur redis Redlock ont ​​un champ d'application étroit et ne conviennent pas à tous les scénarios. .
2. La solution de script Lua basée sur le script Redis peut contrôler de manière flexible la plage de génération d'ID auto-incrémentés et convient aux scénarios qui nécessitent une continuité d'ID de données et des exigences élevées en matière de logique métier.

Par conséquent, lorsque vous choisissez Redis pour mettre en œuvre une solution d'identification distribuée à auto-augmentation, vous devez prendre en compte les besoins spécifiques du scénario commercial et choisir une solution appropriée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!