Les entreprises d'aujourd'hui développent des trafics élevés ASP.NET Core applications Web destinées à d'innombrables utilisateurs simultanés. Dans une architecture en cluster avec à charge équilibrée Sur les serveurs d'applications, plusieurs clients peuvent accéder aux données du cache. Dans ces circonstances, des conditions de concurrence (lorsque deux personnes ou plus tentent d'afficher et de modifier simultanément les mêmes données partagées) se produisent lorsque plusieurs utilisateurs tentent d'accéder aux mêmes données et de les modifier.
De telles conditions de course entraînent souvent incohérence des données et des problèmes d'intégrité. De plus, cela représente un risque pour les applications qui dépendent de la précision des données en temps réel. Heureusement, NCache, les entreprises peuvent tirer parti de la distribution verrouillage mécanismes permettant de garantir une cohérence robuste des données dans un environnement de mise en cache en mémoire évolutif.
Points clés à retenir
- Prévention des conditions liées à la race : Le verrouillage distribué élimine les incohérences de données en garantissant que plusieurs clients simultanés ne peuvent pas modifier les mêmes données mises en cache en même temps.
- Verrouillage optimiste (gestion des versions) : Utilise le système de versionnage interne des éléments pour valider les données avant les mises à jour. Cette solution offre des performances élevées et est idéale pour les environnements où les conflits de données sont rares.
- Verrouillage pessimiste (Exclusif) : Utilise un LockHandle pour verrouiller explicitement un élément à la source. Cette méthode est idéale pour les données critiques où une cohérence stricte prime sur un débit maximal.
- Cohérence évolutive : NCache Il fournit ces mécanismes dans un environnement clusterisé, garantissant ainsi que la logique de verrouillage est synchronisée sur tous les nœuds de cache, et non sur un seul serveur.
- Mise en œuvre stratégique : Le choix entre les deux dépend de votre charge de travail. Vous pouvez utiliser le verrouillage optimiste pour les applications effectuant de nombreuses lectures afin de maintenir la vitesse, et le verrouillage pessimiste pour les applications effectuant de nombreuses écritures afin de garantir une intégrité absolue des données.
Verrouillage distribué pour la cohérence des données
Avec l'aide d' NCache's verrouillage distribué mécanisme, vous pouvez verrouiller des éléments de cache spécifiques pendant les mises à jour simultanées. Cela évite les situations de concurrence, car un seul processus à la fois peut modifier un élément, ce qui garantit l'intégrité des données.
NCache propose deux types de verrouillage :
- Verrouillage optimiste (Versionnage des éléments du cache)
- Verrouillage pessimiste (Verrouillage exclusif)
Pourquoi le verrouillage distribué est-il essentiel à la cohérence des données ?
Prenons l'exemple d'une application bancaire dans laquelle deux utilisateurs accèdent au même compte bancaire avec un solde de 30,000 15,000 USD. Un utilisateur retire 5,000 15,000 USD, tandis que l'autre dépose 35,000 20,000 USD. Si les conditions de concurrence ne sont pas gérées, le solde final peut devenir incorrectement de XNUMX XNUMX USD ou de XNUMX XNUMX USD au lieu de XNUMX XNUMX USD, comme prévu.
Décomposition de la condition de course :
- Temps t1 : L'utilisateur 1 récupère un compte bancaire avec un solde = 30,000 XNUMX
- Temps t2 : L'utilisateur 2 récupère un compte bancaire avec un solde = 30,000 XNUMX
- Temps t3 : L'utilisateur 1 retire 15,000 15,000 et met à jour le solde = XNUMX XNUMX
- Temps t4 : L'utilisateur 2 dépose 5,000 35,000 et met à jour le solde = XNUMX XNUMX
Pour éviter de tels scénarios, NCache's verrouillage les mécanismes garantissent que la logique de votre application est thread-safe et qu'une seule mise à jour est autorisée à la fois.
Verrouillage optimiste (versions d'éléments de cache)
Verrouillage optimiste Usages gestion des versions des éléments du cache pour gérer les mises à jour simultanées. Chaque objet mis en cache possède un numéro de version, qui augmente à chaque modification. Avant de mettre à jour un élément du cache, l'application récupère son numéro de version et le vérifie avant d'enregistrer les modifications. Si une autre mise à jour a modifié la version entre-temps, la mise à jour est rejetée pour maintenir l'intégrité des données.
Figure 1 : Diagramme de séquence de verrouillage optimiste
Mise en œuvre du verrouillage optimiste NCache
Pour implémenter le verrouillage optimiste, reportez-vous à l'exemple de code ci-dessous :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//The following C# example demonstrates version-based updates where the "Insert" operation succeeds only if the "version" matches the server-side value. using Alachisoft.NCache.Client; ICache cache = CacheManager.GetCache("myCache"); string key = "order:456"; // Retrieve item with version CacheItem cacheItem = cache.GetCacheItem(key); long version = cacheItem.Version; // Modify data Order order = (Order)cacheItem.Value; order.Status = "Shipped"; try { // Update only if the version matches cache.Insert(key, new CacheItem(order), version); Console.WriteLine("Update successful."); } catch (OperationFailedException ex) { Console.WriteLine("Optimistic lock failed: " + ex.Message); } |
Verrouillage pessimiste (verrouillage exclusif)
Verrouillage pessimiste empêche les autres utilisateurs de modifier un élément du cache jusqu'à ce que le verrou soit libéré. Cette approche est utile dans les scénarios où un contrôle strict sur la modification des données est requis.
Figure 2 : Diagramme de séquence de verrouillage pessimiste
Mise en œuvre du verrouillage pessimiste NCache
Pour mettre en œuvre le verrouillage pessimiste NCache, veuillez consulter l'exemple de code ci-dessous :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//This snippet shows how to acquire an explicit lock using "AcquireLock", ensuring no other thread can modify the item until "ReleaseLock" is called. using Alachisoft.NCache.Client; using Alachisoft.NCache.Runtime.Exceptions; ICache cache = CacheManager.GetCache("myCache"); string key = "customer:123"; LockHandle lockHandle = new LockHandle(); try { // Acquire lock with a timeout cache.AcquireLock(key, TimeSpan.FromSeconds(10), out lockHandle); // Perform operations while holding the lock Customer customer = (Customer)cache.Get(key, lockHandle); customer.Name = "Updated Name"; cache.Insert(key, new CacheItem(customer), lockHandle); } catch (LockingException ex) { Console.WriteLine("Lock acquisition failed: " + ex.Message); } finally { // Release the lock cache.ReleaseLock(key, lockHandle); } |
Verrouillage pendant l'obtention et libération du verrouillage lors de l'insertion
Une autre approche de verrouillage pessimiste consiste à verrouiller un élément lorsque aller chercher elle et libérer le verrou pendant la mise à jour de l'élément. Cela garantit que les données récupérées restent inchangées jusqu'à ce que la mise à jour soit terminée.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
using Alachisoft.NCache.Client; using Alachisoft.NCache.Runtime.Exceptions; ICache cache = CacheManager.GetCache("myCache"); string key = "product:789"; LockHandle lockHandle = new LockHandle(); try { // Lock item during Get operation Product product = (Product)cache.Get(key, TimeSpan.FromSeconds(10), out lockHandle); // Modify the product data product.Price += 10; // Update item and release the lock cache.Insert(key, new CacheItem(product), lockHandle, true); } catch (LockingException ex) { Console.WriteLine("Lock operation failed: " + ex.Message); } finally { // Ensure the lock is released if not already released cache.ReleaseLock(key, lockHandle); } |
| Fonctionnalité | Verrouillage optimiste (gestion des versions) | Verrouillage pessimiste (Exclusif) |
| Mécanisme de base | Utilise le contrôle de version des éléments. Le système vérifie si la version a changé depuis la dernière récupération. | Utilise LockHandle. Le système accorde un accès exclusif à un seul utilisateur pendant une durée déterminée. |
| Niveau de simultanéité | Élevé. Plusieurs utilisateurs peuvent lire et tenter des mises à jour simultanément sans blocage. | Faible. Un seul utilisateur peut accéder à l'élément pour le modifier ; les autres doivent attendre. |
| Impact sur les performances | Minimale. Aucun verrou physique n'est installé sur le serveur, ce qui garantit un débit maximal. | Modérée à élevée. Peut engendrer des goulots d'étranglement si les verrous sont maintenus trop longtemps ou si la contention est importante. |
| Gestion des conflits | En cas d'incompatibilité de versions, la mise à jour échoue et l'application doit réessayer (détection de conflit). | Les conflits sont évités en bloquant les autres utilisateurs jusqu'à ce que le verrou soit levé (Prévention des conflits). |
| Cas d'utilisation idéal | Données à forte intensité de lecture / faible contention. Ex. : catalogues de produits, profils d’utilisateurs ou données de configuration. | Écritures fréquentes / Intégrité élevée. Ex. : soldes financiers, inventaires ou réservations de sièges. |
Conclusion
En employant NCacheGrâce aux fonctionnalités de verrouillage distribué, les développeurs peuvent garantir une cohérence élevée des données dans les applications distribuées. Le verrouillage pessimiste offre un contrôle strict des mises à jour critiques, tandis que le verrouillage optimiste offre des performances supérieures pour les scénarios à faible conflit. La mise en œuvre de ces stratégies garantit l'intégrité des données, même sous des charges de travail à forte concurrence, ce qui permet aux applications d'être fiables et évolutives.
Questions fréquentes
- Qu'est-ce que le verrouillage dans un cache distribué ?
Le verrouillage dans un cache distribué est un mécanisme qui garantit qu'un seul client peut modifier un élément mis en cache à la fois sur plusieurs serveurs, évitant ainsi les conflits de mise à jour simultanées. - Pourquoi le verrouillage est-il important pour la cohérence des données ?
Le verrouillage empêche les conflits d'accès concurrents et les pertes de mises à jour lorsque plusieurs applications ou services tentent de lire ou d'écrire simultanément les mêmes données mises en cache. - En quoi le verrouillage de cache distribué diffère-t-il du verrouillage de base de données ?
Le verrouillage de cache distribué fonctionne sur les nœuds d'application et les serveurs de cache en mémoire, tandis que le verrouillage de base de données fonctionne généralement au niveau du stockage et peut introduire une latence plus élevée. - L'utilisation du verrouillage dans un cache distribué a-t-elle un impact sur les performances ?
Oui, le verrouillage introduit une surcharge de coordination, il doit donc être utilisé de manière sélective pour les données exigeant une cohérence stricte plutôt que pour les charges de travail à haut débit et à forte intensité de lecture.
