Questions d'entretien classiques Java : comment Redis et Mysql assurent la cohérence des données

introduction

La cohérence des données est un concept très important en informatique et en systèmes distribués. Cela fait référence au maintien de l'exactitude et de la cohérence des données entre plusieurs copies de données, en garantissant que les données ont la même valeur entre les copies et que ces copies ne produisent pas de conflits ou d'états incohérents à aucun moment. La cohérence des données est essentielle au bon fonctionnement des applications et à l'expérience utilisateur, en particulier dans les systèmes distribués où les données sont stockées sur plusieurs emplacements géographiques ou serveurs.

importance

• Exactitude des données : dans toute application, il est crucial de garantir l’exactitude des données. Si les données sont incohérentes sur plusieurs réplicas, les applications peuvent fournir des informations incorrectes aux utilisateurs, entraînant un comportement et des résultats imprévisibles.

• Expérience utilisateur : des données cohérentes permettent aux utilisateurs de basculer de manière transparente entre les différentes parties de l'application, offrant ainsi une expérience utilisateur unifiée. Par exemple, un panier sur un site commercial doit afficher le même contenu sur différents appareils.

• Fiabilité et robustesse : la cohérence des données peut améliorer la fiabilité et la robustesse du système. Lorsqu'un nœud ou un serveur tombe en panne, le système peut rapidement récupérer à partir d'autres nœuds et maintenir la cohérence des données.

défi

• Latence : dans les systèmes distribués, les délais de réseau entre les différents nœuds sont courants. Lorsque les données sont mises à jour sur un nœud, les autres nœuds peuvent ne pas recevoir les dernières données en raison d'un retard, ce qui entraîne une incohérence des données.

• Écritures simultanées : des conflits de concurrence peuvent survenir lorsque plusieurs clients tentent d'écrire des données en même temps. Dans un système distribué, plusieurs réplicas peuvent recevoir des demandes de mise à jour en même temps, et ces mises à jour peuvent entrer en conflit les unes avec les autres, entraînant une incohérence des données.

• Gestion des pannes : les pannes de nœuds peuvent entraîner une perte de données ou des mises à jour, ce qui peut entraîner une incohérence des données. Des mécanismes appropriés de gestion des pannes doivent être en place pour garantir la restauration de la cohérence des données après une panne de nœud.

• Mécanisme de synchronisation : dans un système distribué, afin de maintenir la cohérence des données, un mécanisme de synchronisation efficace est requis. Cependant, le mécanisme de synchronisation peut entraîner une dégradation des performances car la synchronisation des données peut prendre beaucoup de temps.

Présentation de Redis et MySQL

Bases de données Redis et MySQL, leurs différentes utilisations dans les applications.

Redis (serveur de dictionnaire à distance)

Redis est un système de base de données open source basé sur la mémoire, connu sous le nom de magasin clé-valeur car il stocke les données sous forme de paires clé-valeur. Voici quelques fonctionnalités de Redis :

• Stockage des données en mémoire : Redis stocke les données en mémoire, la vitesse de lecture est donc très rapide, adaptée aux applications hautes performances.

• Stockage de paires clé-valeur : les données sont stockées sous forme de paires clé-valeur et diverses structures de données telles que des chaînes, des tables de hachage, des listes, des ensembles, des ensembles ordonnés, etc.

• Hautes performances : étant donné que les données sont stockées en mémoire, Redis fonctionne bien dans les opérations de lecture et d'écriture et est particulièrement adapté comme couche de cache.

• Persistance des données : Redis prend en charge la persistance des données sur le disque pour éviter la perte de données.

• Modèle de publication/abonnement : Redis prend en charge les fonctionnalités de publication et d'abonnement, ce qui en fait un bon choix pour gérer les messages et les événements en temps réel.

Scénarios applicables : Redis convient aux scénarios qui nécessitent des performances élevées, une faible latence et un traitement des données en temps réel, tels que la mise en cache, le stockage de session, les statistiques et le comptage en temps réel, les classements et la messagerie en temps réel.

MySQL

MySQL est un système de gestion de base de données relationnelle (SGBDR) qui utilise le langage de requête structuré (SQL) pour la manipulation des données. Voici quelques fonctionnalités de MySQL :

• Base de données relationnelle : MySQL stocke les données sous forme de tableaux et prend en charge des modèles de données relationnelles complexes.

• Prise en charge des transactions ACID : MySQL prend en charge les transactions ACID (atomicité, cohérence, isolation et durabilité) pour garantir la cohérence et l'intégrité des données.

• Persistance des données : MySQL stocke les données de manière persistante sur le disque pour garantir qu'elles ne seront pas perdues en cas de panne de courant ou de panne.

• Requête complexe : MySQL prend en charge un langage de requête SQL puissant, adapté aux requêtes de données complexes et à la génération de rapports.

• Prise en charge de plusieurs moteurs de stockage : MySQL prend en charge plusieurs moteurs de stockage, tels que InnoDB, MyISAM, etc., et vous pouvez choisir différents moteurs en fonction de vos besoins.

Scénarios applicables : MySQL convient aux applications qui nécessitent une cohérence stricte des données et des requêtes complexes, telles que les sites Web de commerce électronique, les systèmes de gestion, l'analyse des données et les rapports, etc.

Redis convient aux scénarios qui nécessitent des performances élevées et un traitement de données en temps réel, tels que la mise en cache, le comptage en temps réel et la messagerie, tandis que MySQL convient aux applications qui nécessitent une cohérence stricte des données et des requêtes complexes, telles que le commerce électronique et les données. les systèmes de gestion. Dans les applications pratiques, vous pouvez choisir un système de base de données approprié ou les utiliser en combinaison en fonction de besoins et de scénarios spécifiques pour obtenir les meilleures performances et cohérence des données.

Présentation de la cohérence des données

• Vérifier l'exactitude des données : dans un système distribué, plusieurs nœuds peuvent lire et écrire des données en même temps. Si les données ne sont pas cohérentes entre les nœuds, cela peut entraîner des conflits de données entre les nœuds, ce qui peut entraîner des résultats incorrects et une corruption des données.

• Évitez les données sales : si un nœud modifie des données, mais qu'en raison de la latence du réseau ou d'autres problèmes, ces modifications n'ont pas été répliquées sur d'autres nœuds, ces derniers peuvent alors lire des données anciennes et incohérentes, ce qui entraîne des données sales.

• Haute disponibilité et tolérance aux pannes : lorsqu'un nœud tombe en panne ou tombe en panne, d'autres nœuds doivent prendre en charge le service et continuer à fonctionner. Si les données sont incohérentes, le nouveau nœud risque de ne pas être en mesure de traiter correctement les demandes des autres nœuds.

• Exécution correcte garantie des transactions : Dans un système distribué, il peut être nécessaire d'exécuter des transactions composées de plusieurs opérations. La cohérence des données garantit que ces opérations sont toutes exécutées avec succès ou échouent toutes, évitant ainsi les erreurs de logique de données causées par la réussite d'opérations partielles.

• Sauvegarde des données : dans un système distribué, la sauvegarde des données est une exigence très courante. Si les données sont incohérentes sur le nœud de sauvegarde, l'intégrité et la validité de la sauvegarde seront compromises.

Mécanisme de cohérence des données Redis

• Transactions : Redis prend en charge les transactions, permettant de regrouper et d'exécuter plusieurs commandes en une seule opération atomique. Dans une transaction, toutes les commandes s'exécutent avec succès ou échouent, et Redis n'insérera pas de commandes d'autres clients pendant l'exécution de la transaction. Le processus d'exécution de la transaction est atomique, c'est-à-dire qu'il ne sera pas interrompu pendant le processus d'exécution, garantissant ainsi la cohérence des données.
  L'exécution de la transaction est divisée en trois étapes : démarrer la transaction, mettre la commande en file d'attente et exécuter la transaction. Si une erreur survient lors de l'exécution d'une transaction, Redis annulera l'intégralité de la transaction pour garantir la cohérence des données. Dans Redis, utilisez la commande MULTI pour démarrer une transaction, puis utilisez la commande EXEC pour exécuter la transaction ou utilisez la commande DISCARD pour annuler la transaction.

• Persistance : Afin de garantir que les données ne seront pas perdues lors d'un redémarrage ou d'une panne, Redis propose deux méthodes de persistance : RDB (Redis Database Dump) et AOF (Append-only File).
  Persistance RDB : enregistrez périodiquement des instantanés de données en mémoire dans des fichiers RDB sur le disque. Le processus de persistance peut être déclenché en configurant des sauvegardes périodiques ou en exécutant manuellement la commande SAVE ou BGSAVE. La persistance RDB peut garantir la cohérence des données lors de la sauvegarde et de la récupération des données.

• Persistance AOF : ajoutez la commande d'écriture au fichier AOF et enregistrez l'opération de modification des données. Lorsque Redis redémarre, restaurez les données en réexécutant les commandes du fichier AOF. La persistance AOF peut garantir la cohérence des données lors de la récupération après panne.

• Réplication : Redis prend en charge le mécanisme de réplication maître-esclave, qui réalise la sauvegarde des données et la haute disponibilité en répliquant les données d'une instance Redis (nœud maître) vers d'autres instances Redis (nœuds esclaves).
  Pendant le processus de réplication, le nœud maître envoie des commandes d'écriture à tous les nœuds esclaves connectés, et les nœuds esclaves exécutent la même commande d'écriture pour maintenir la cohérence des données. Si le nœud maître échoue, le nœud esclave peut élire un nouveau nœud maître pour continuer à fournir des services. Grâce à la réplication, même en cas de défaillance du nœud maître, les données restent disponibles, garantissant ainsi leur cohérence et leur haute disponibilité.

Redis garantit la cohérence des données grâce à des mécanismes tels que les transactions, la persistance et la réplication. Les transactions garantissent l'exécution atomique de plusieurs commandes, la persistance garantit que les données ne seront pas perdues en cas de redémarrage ou de panne, et la réplication garantit la sauvegarde et la haute disponibilité des données. Ces mécanismes fonctionnent ensemble pour faire de Redis une solution de stockage de données offrant des performances élevées, une haute disponibilité et une forte cohérence des données.

Mécanisme de cohérence des données MySQL

• Prise en charge des transactions : MySQL prend en charge les transactions, ce qui signifie qu'un ensemble d'opérations peut être considéré comme une seule unité de travail. Les transactions peuvent garantir que ces opérations sont exécutées avec succès ou annulées, maintenant ainsi la cohérence des données.

• Propriétés ACID : MySQL suit les propriétés ACID, à savoir l'atomicité (Atomicité), la cohérence (Consistence), l'isolation (Isolation) et la persistance (Durabilité). Ces propriétés garantissent que la base de données maintient la cohérence et la fiabilité des données dans diverses circonstances.

• Réplication : MySQL fournit une fonctionnalité de réplication qui permet de copier les données d'un serveur de base de données vers d'autres serveurs. Cette réplication peut être utilisée pour mettre en œuvre la sauvegarde des données et la récupération après panne. La réplication peut être établie entre la base de données maître et une ou plusieurs bases de données esclaves pour assurer la cohérence des données sur les différents nœuds.

MySQL maintient la cohérence des données en prenant en charge les transactions, en suivant les propriétés ACID et en fournissant des fonctions de réplication pour garantir l'exactitude et la fiabilité des données dans un environnement distribué.

Défis de cohérence des données entre Redis et MySQL

Lorsque vous utilisez Redis et MySQL, vous pouvez rencontrer des problèmes de cohérence des données car les deux ont des caractéristiques et des objectifs différents. Redis est une base de données en mémoire pour la mise en cache et les opérations de lecture et d'écriture rapides, tandis que MySQL est une base de données relationnelle traditionnelle pour les données persistantes et prenant en charge les requêtes complexes. Voici quelques problèmes de cohérence que vous pourriez rencontrer et comment les résoudre :

Conditions de concurrence : dans un environnement concurrent, plusieurs clients lisent et écrivent simultanément des données, ce qui peut entraîner des conditions de concurrence. Par exemple, un client lit des données tandis qu'un autre client modifie les mêmes données, ce qui peut entraîner une incohérence des données.

Solution:

1. Utilisation de transactions : dans MySQL, l'utilisation de transactions peut traiter une série d'opérations comme des unités atomiques, soit toutes soumises avec succès, soit toutes annulées. Cela garantit que les opérations de données au sein de la transaction sont sérialisées, évitant ainsi les conditions de concurrence.
   Utiliser les transactions Redis : Redis prend en charge les opérations de transaction. Vous pouvez regrouper plusieurs commandes dans une seule transaction et les exécuter ensemble, ce qui peut garantir l'atomicité de ces commandes.
   Expiration des données et incohérence : dans Redis, vous pouvez définir le délai d'expiration de la clé, mais il n'y a pas de concept d'expiration intégré dans MySQL. Si une clé expire dans Redis et que les données correspondantes dans MySQL ne sont pas mises à jour, cela peut entraîner une incohérence des données.

2. Définir raisonnablement le délai d'expiration : définissez un délai d'expiration raisonnable dans Redis pour garantir que les données sont mises à jour dans un certain laps de temps.
   Utilisez un mécanisme de synchronisation régulier : vous pouvez synchroniser périodiquement les données de Redis vers MySQL pour garantir la cohérence des données.
   Perte de données : Redis étant une base de données en mémoire, si le serveur tombe en panne ou redémarre, les données en mémoire peuvent être perdues. Cependant, MySQL en tant que base de données sur disque a généralement une persistance.

3. Utiliser la persistance : Redis propose deux méthodes de persistance : l'instantané RDB et le journal AOF. Vous pouvez choisir de conserver périodiquement les données sur le disque pour éviter toute perte de données.
   Utilisez MySQL comme base de données principale : si la persistance des données est importante pour vous, vous pouvez stocker les données dans MySQL comme base de données principale et Redis comme couche de cache. De cette façon, même si les données de Redis sont perdues, elles peuvent être récupérées à partir de MySQL.
   Délai de synchronisation des données : lorsque Redis et MySQL sont utilisés pour la séparation en lecture-écriture ou la réplication maître-esclave, en raison du retard du réseau ou pour d'autres raisons, la synchronisation des données peut être retardée, entraînant une incohérence des données.

4. Remplacez la réplication asynchrone par une réplication synchrone : si une forte cohérence des données est très importante, vous pouvez envisager de remplacer la réplication maître-esclave de MySQL par une réplication synchrone pour garantir l'immédiateté de la synchronisation des données.

5. Mode double écriture : lorsque vous effectuez des opérations d'écriture, écrivez sur Redis et MySQL en même temps pour garantir la cohérence des données. Cependant, cela peut affecter les performances d'écriture.

Pour garantir la cohérence des données entre Redis et MySQL, il est nécessaire de prendre en compte de manière globale les besoins de l'entreprise, les exigences de performances et l'importance des données. L'utilisation de transactions, la synchronisation périodique, la définition raisonnable du délai d'expiration et la sélection de méthodes de persistance appropriées sont autant de moyens de résoudre les problèmes de cohérence.

Meilleures pratiques pour garantir la cohérence des données

Par exemple, une communication de messages fiable basée sur RocketMQ, RabbitMQ ou d'autres files d'attente de messages pour obtenir une cohérence finale.

Vous pouvez également surveiller directement les journaux binlog dans Mysql via le composant Canal et synchroniser les données mises à jour avec Redis.

Cas d'application pratique

Scénario 1 : mise à jour du solde du compte utilisateur

Supposons que nous ayons un site Web de commerce électronique sur lequel les utilisateurs peuvent augmenter le solde de leur compte en rechargeant. Nous pouvons utiliser Redis et MySQL pour maintenir des soldes de comptes utilisateur cohérents.

1. Lorsque l'utilisateur effectue une opération de recharge, la demande de recharge est d'abord envoyée à Redis et le solde du compte utilisateur est augmenté du montant correspondant via la commande INCRBY de Redis.

2. Ensuite, écrivez la demande de recharge dans la table d'enregistrement de recharge de MySQL, y compris des informations telles que l'ID utilisateur et le montant de la recharge.

3. Dans la tâche en arrière-plan, en surveillant la demande de recharge dans Redis, elle est synchronisée avec la table des comptes utilisateur dans MySQL. Vous pouvez utiliser la commande SUBSCRIBE de Redis pour surveiller la demande de recharge, et lors de la réception de la demande, retirer l'ID utilisateur correspondant et le montant de recharge de Redis, puis mettre à jour la table des comptes utilisateur dans MySQL.

4. De cette façon, que l'utilisateur interroge le solde du compte ou effectue d'autres opérations, les dernières données de solde peuvent être obtenues à partir de MySQL, garantissant ainsi la cohérence des données.

Scénario 2 : Statistiques en temps réel des vues d'articles

1. Supposons que nous ayons un site Web de communiqués de presse et que nous devions compter le nombre de vues de chaque article en temps réel. Nous pouvons utiliser Redis et MySQL pour maintenir la cohérence des vues des articles.

2/ Lorsqu'un utilisateur visite un article, stockez d'abord l'ID de l'article dans Redis et augmentez le volume de vue de l'article correspondant de 1 via la commande INCR de Redis.

3. Ensuite, périodiquement (par exemple, toutes les minutes), écrivez les données de consultation de page dans Redis dans la table d'articles de MySQL. Vous pouvez utiliser la commande ZREVRANGE de Redis pour obtenir les principaux ID et vues des articles, puis les écrire dans MySQL.

4. De cette façon, lorsque le nombre de visites d'utilisateurs est important, le nombre de visites peut être rapidement augmenté via Redis et il est périodiquement synchronisé avec MySQL pour garantir la cohérence des données. Dans le même temps, les utilisateurs peuvent également obtenir les dernières données de MySQL lorsqu'ils interrogent les pages vues des articles.

Résumer

Comment Redis garantit la cohérence des données

• Synchrone à l'écriture : Redis écrit les données dans la mémoire par défaut et sur le disque de manière asynchrone. Les données peuvent être écrites sur le disque de manière synchrone en configurant les options de persistance pour garantir la persistance des données après une panne de courant ou un redémarrage. Cette méthode convient aux scénarios nécessitant peu de données en temps réel.
• Réplication maître-esclave : Redis prend en charge un mécanisme de réplication maître-esclave, dans lequel le nœud maître synchronise les données avec le nœud esclave de sauvegarde. Grâce à la stratégie de réplication et au mécanisme de surveillance, la cohérence des données entre les nœuds maître et esclave est garantie. Cette méthode convient aux scénarios dans lesquels les lectures et les écritures sont séparées et peut améliorer les performances de lecture.
• Mode sentinelle : le mode sentinelle de Redis est utilisé pour surveiller l'état de santé du nœud maître-esclave et effectuer une commutation maître-esclave automatique en cas de panne du nœud maître. Cette approche garantit la cohérence des données lors du basculement.

Comment MySQL garantit la cohérence des données

• Transactions ACID : MySQL prend en charge les transactions ACID, à savoir l'atomicité, la cohérence, l'isolation et la durabilité. Grâce aux opérations de démarrage, de validation et d'annulation des transactions, MySQL garantit l'atomicité des opérations de données et fournit différents niveaux d'isolation pour contrôler la visibilité et la cohérence entre les opérations simultanées.
• Mécanisme de verrouillage : MySQL utilise des verrous pour gérer les opérations d'accès simultané et de modification des données. Grâce aux verrous en lecture-écriture et aux verrous de transaction, l'isolation et la cohérence des données entre plusieurs transactions sont réalisées. Lors de la lecture et de la modification de données, utilisez les types de verrous appropriés, tels que les verrous de ligne, les verrous de table et les verrous de page, pour garantir la cohérence des données.
• Réplication maître-esclave : MySQL prend en charge la réplication maître-esclave, qui synchronise les données du nœud maître vers le nœud esclave de sauvegarde. En configurant des stratégies de réplication et des mécanismes de surveillance appropriés, la cohérence des données entre les nœuds maîtres et esclaves est assurée.

Il est très important de choisir la bonne solution en fonction des exigences de l'application. Si l'application a des exigences élevées en matière de performances en temps réel, vous pouvez choisir Redis et configurer la stratégie de synchronisation et le mode sentinelle pour garantir l'actualité et la disponibilité des données ; si l'application a des exigences plus élevées en matière de cohérence et d'intégrité des données, vous pouvez choisir MySQL et utilisez les transactions ACID et les mécanismes de verrouillage appropriés pour garantir la cohérence des données. Dans le même temps, les performances peuvent être améliorées en combinant la réplication maître-esclave et la séparation lecture-écriture en fonction du taux d'accès en lecture-écriture et des conditions de charge dans des scénarios spécifiques. En conclusion, choisir la bonne solution en fonction des exigences de l’application est la clé pour garantir la cohérence des données.