Comment Redis assure la cohérence des transactions distribuées

Redis est une base de données à mémoire distribuée hautes performances qui est largement utilisée dans les systèmes distribués. Dans les systèmes distribués, comment assurer la cohérence des transactions a toujours été un problème, et le mécanisme de transaction fourni par Redis peut aider les développeurs à résoudre ce problème. Cet article présentera comment Redis assure la cohérence des transactions distribuées et montrera des exemples de code.

1. Introduction au mécanisme de transaction Redis

Redis fournit un mécanisme de transaction dans la version 2.0, qui est implémenté via cinq commandes : MULTI, EXEC, WATCH, DISCARD et UNWATCH. Les opérations de la transaction seront enregistrées séquentiellement dans une file d'attente et exécutées par lots lorsque la commande EXEC est appelée. Si la transaction entière est soumise avec succès, toutes les opérations dans la file d'attente d'enregistrement seront exécutées dans l'ordre ; si une opération échoue, la transaction entière sera annulée. Plusieurs clients peuvent démarrer leurs propres transactions en même temps Puisqu'elles sont exécutées dans la file d'attente des enregistrements d'opérations, les transactions sont indépendantes les unes des autres.

2. Principe de mise en œuvre des transactions distribuées Redis

Dans les transactions autonomes Redis, chaque client est traité par le même processus, mais dans une situation distribuée, chaque client peut correspondre à une instance Redis différente. être mis en œuvre pour garantir l’exactitude des données.

La clé de la mise en œuvre de transactions distribuées dans Redis réside dans les commandes WATCH et UNWATCH. Chaque client peut marquer certaines données clés dans Redis via la commande WATCH. Lorsque ces données sont modifiées par d'autres clients, la transaction du client sera terminée. Cette marque peut être supprimée via la commande UNWATCH. La raison en est que lorsque l'utilisateur démarre une transaction, s'il y a la même concurrence d'écriture avec d'autres clients, la transaction sera annulée et un signal d'échec de transaction sera défini. Dans ce processus, le client doit identifier de manière unique toutes ses données clés qui doivent être surveillées. Lorsqu'un conflit survient, le client utilisera ces identifications pour déterminer si la transaction doit être annulée. Si une restauration est requise, le client réessaye la transaction.

3. Exemple de code

Ci-dessous, nous utilisons Python pour implémenter une transaction distribuée simple, simulant deux clients pour exécuter des transactions sur différentes instances Redis afin d'implémenter les opérations de transfert. Le transfert doit être réussi et peut être implémenté à l'aide de la commande WATCH/UNWATCH. Contrôle de cohérence.

Prérequis :

• Python 3.x
• Redis-py

Le code est le suivant :

import redis

# 新建两个 Redis 实例 
redis1 = redis.StrictRedis(host="localhost", port=6379, db=0)
redis2 = redis.StrictRedis(host="localhost", port=6380, db=0)

# 我们模拟一下一个转帐操作
def transfer(from_user, to_user, value):
    # 两个实例都要执行事务
    tx = redis1.pipeline()
    tx2 = redis2.pipeline()

    # Watch 监控 from_user 和 to_user 的 balance 值
    tx.watch(from_user, to_user)
    tx2.watch(from_user, to_user)

    # 如果 from_user 的 balance 值减去转账数值，小于0
    if tx.get(from_user) < int(value):
        tx.unwatch()
    else:
        tx.multi()
        tx.decrby(from_user, int(value))

        # 通过2个实例之间的网络通信，将 balance 放入另一个
        tx2.multi()
        tx2.incrby(to_user, int(value))

        print(tx.execute())
        print(tx2.execute())

transfer('user1', 'user2', '100') #执行转账操作

Deux nouvelles instances Redis sont créées dans le code. Ensuite, une fonction de transfert est définie, qui simule une opération de transfert et nécessite que les paramètres from_user, to_user et value du transfert soient transmis. Au sein de la fonction, la partie essentielle consiste à utiliser la commande WATCH pour surveiller les valeurs d'équilibre de from_user et to_user sur deux instances Redis afin d'éviter les conditions de concurrence pendant le processus de transfert. Utilisez ensuite la transaction pour modifier le solde sur les deux instances Redis afin de garantir la cohérence de l'opération de transfert.

Résumé

Redis prend en charge le mécanisme de transaction, qui peut garantir la cohérence sur une seule instance Redis. Cependant, dans un environnement distribué, afin de garantir la cohérence sur plusieurs instances Redis, un mécanisme de transaction distribué doit être introduit. Redis implémente ce mécanisme via les commandes WATCH et UNWATCH. Nous pouvons mieux comprendre les principes de mise en œuvre des transactions distribuées Redis grâce à des exemples de code.

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!