Explication détaillée des transactions distribuées implémentées par Redis

Avec la croissance continue des transactions sur Internet, les transactions distribuées sont devenues un élément essentiel des systèmes d'entreprise. Avec l'enrichissement continu des méthodes de mise en œuvre de transactions distribuées, Redis, en tant que base de données en mémoire largement utilisée, devient progressivement le premier choix pour la mise en œuvre de transactions distribuées. Cet article présente principalement comment Redis implémente les transactions distribuées.

Modèle de transaction de Redis

Le modèle de transaction pris en charge par Redis est une opération par lots. Au sein d'une transaction, Redis peut exécuter plusieurs commandes. Plusieurs commandes réussissent ou échouent toutes dans la même transaction, garantissant l'intégrité de la transaction, afin que Redis puisse bien prendre en charge la transactionnalité.

Le principe de base des transactions Redis est de regrouper plusieurs commandes en une seule transaction, puis de les exécuter de manière atomique. Cependant, il convient de noter que le processus d'exécution des transactions Redis est différent des autres bases de données relationnelles. effectuera les étapes suivantes :

1. Démarrer la transaction
2 Exécuter plusieurs commandes
3. Soumettre la transaction

Mais le processus d'exécution de la transaction Redis. Comme suit :

1. Démarrez la transaction
2. Exécutez plusieurs commandes
3. Commande de cache de file d'attente
4. Lorsque Redis exécute une transaction, il place plusieurs commandes dans la file d'attente et ces commandes seront exécutées de manière atomique jusqu'à ce que la transaction soit soumise. Si une erreur se produit lors de l'exécution de la transaction, Redis renverra le code d'erreur au client et n'exécutera pas les commandes non exécutées dans la transaction.

Instance de transaction Redis

Le code suivant démontre l'utilisation simple de la transaction Redis :

require 'redis'

# 连接Redis数据库
redis = Redis.new(host: 'localhost', port: 6379)

# 初始化一个Redis事务对象
redis.multi do
  redis.set('key1', 'value1')
  redis.set('key2', 'value2')
end

Dans le code ci-dessus, nous utilisons une transaction Redis objet pour exécuter deux commandes. Le but de cette transaction est de définir la valeur de key1 sur value1 et la valeur de key2 sur value2. Utilisez la méthode multi pour démarrer une transaction Redis, utilisez la méthode set pour définir la valeur de la clé et utilisez la méthode exec pour soumettre la transaction Redis. Enfin, Redis regroupera automatiquement ces commandes dans une transaction pour une exécution atomique.

La mise en œuvre des transactions distribuées Redis

Dans un système distribué, les données des opérations de transaction peuvent être distribuées dans différents nœuds, un mécanisme est donc nécessaire pour assurer la cohérence transactionnelle de la distribution. Les transactions distribuées de Redis ont les méthodes d'implémentation suivantes :

1. Utilisez la commande WATCH de Redis

En utilisant la commande WATCH, Redis peut surveiller une ou plusieurs variables clés. Si ces variables ont été modifiées lors de l'exécution précédente de la commande, la transaction cessera de s'exécuter, ce qui peut éviter les erreurs causées par la mise à jour des données lors du traitement de la transaction. Voici un exemple d'utilisation de WATCH :

require 'redis'

# 连接Redis数据库
redis = Redis.new(host: 'localhost', port: 6379)

# 监视key
redis.watch('key')

# 开始事务
redis.multi do
  redis.set('key1', 'value1')
end

# 提交事务
redis.exec

Dans le code ci-dessus, nous utilisons watch pour surveiller si la clé a été modifiée. Lorsque la transaction commence à s'exécuter, s'il s'avère que la clé a été modifiée. a été modifié, l'exécution de la transaction sera terminée, une fois la transaction exécutée, elle est soumise via la méthode exec.

2. Utilisez le verrouillage de transaction Redis

Si vous utilisez la commande WATCH, vous devez tenir compte de la situation d'accès simultané par plusieurs clients, ce qui entraînera une dégradation des performances. Par conséquent, Redis fournit également une solution de verrouillage distribué, qui peut utiliser l'instruction SETNX ou l'instruction SET de Redis pour implémenter des verrous de transaction. L'instruction SETNX ne sera définie avec succès que lorsque la clé définie n'existe pas. Cela garantit que la clé ne sera obtenue que par un seul client. Le délai d'expiration de la clé peut être défini via l'instruction SET pour garantir l'unicité et la sécurité de la. verrouillage. Le code est le suivant :

require 'redis'

# 连接Redis数据库
redis = Redis.new(host: 'localhost', port: 6379)

# 设置Redis锁
redis.set('lock_key', 'value', ex: 10, nx: true)

# 执行事务
redis.multi do
  redis.set('key1', 'value1')
end

# 释放Redis锁
redis.del('lock_key')

# 提交事务
redis.exec

Dans le code ci-dessus, nous utilisons l'instruction set pour définir le verrou, définir le délai d'expiration sur 10 secondes et définir le paramètre nx en même temps pour éviter les répétitions. acquisition de la serrure.

3. Utilisez le script Lua de Redis

En plus des deux méthodes ci-dessus, vous pouvez également utiliser le script Lua de Redis pour implémenter la fonction de transaction distribuée. Les scripts Lua prennent en charge les opérations atomiques et plusieurs commandes peuvent être exécutées dans la même opération. En personnalisant les scripts Lua, nous pouvons regrouper plusieurs commandes Redis dans une opération atomique pour réaliser des transactions distribuées. Voici un exemple d'utilisation du script Lua :

redis.call('WATCH', KEYS[1])

if redis.call('GET', KEYS[1]) == ARGV[1] then
    redis.call('MULTI')
    redis.call('SET', KEYS[1], ARGV[2])
    redis.call('SET', KEYS[2], ARGV[3])
    redis.call('EXEC')
end

redis.call('UNWATCH')

Dans le code ci-dessus, nous utilisons le script Lua pour implémenter les transactions distribuées. Avant le démarrage de la transaction, utilisez l'instruction WATCH pour surveiller l'état de la clé. Après exécution, utilisez l'instruction UNWATCH pour annuler la surveillance de la clé. Grâce aux scripts Lua, nous pouvons regrouper plusieurs commandes Redis dans une opération atomique pour réaliser des transactions distribuées.

Summary

Le modèle de transaction de Redis est une opération par lots, garantissant l'intégrité de la transaction. Dans un système distribué, les données d'opération de transaction peuvent être distribuées entre différents nœuds, un mécanisme est donc nécessaire pour garantir la cohérence des transactions distribuées. Redis propose trois méthodes d'implémentation : la commande WATCH, le verrouillage de transaction et le script Lua. La méthode à choisir doit être choisie en fonction des besoins de l'entreprise.

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!