Verrous exclusifs sur les éléments (verrouillage pessimiste)
NCache fournit un mécanisme de verrouillage pessimiste qui verrouille exclusivement les données mises en cache. Ce mécanisme verrouille l'élément à l'aide de la poignée de verrouillage, ce qui empêche tous les autres utilisateurs d'effectuer toute opération d'écriture sur cet élément du cache. UN LockHandle
est associé à chaque élément verrouillé dans le cache, qui est renvoyé par l'API de verrouillage.
Notes
Cette fonctionnalité est également disponible dans NCache Professional.
Un élément verrouillé peut être récupéré/mis à jour ou déverrouillé uniquement lorsque son handle de verrouillage est fourni au niveau de l'API. Cependant, vous devez le faire avec précaution pour éviter les problèmes d’intégrité des données. Le verrouillage pessimiste est une très bonne approche si l’objectif à atteindre est la cohérence des données.
Une fois qu'un verrou est acquis à l'aide de LockHandle
, il existe deux mécanismes pour le libérer. Ces deux mécanismes sont expliqués ci-dessous.
Déverrouillage temporel des serrures : Vous pouvez également spécifier un délai d'attente de verrouillage lors du verrouillage d'un élément mis en cache. Le délai d'expiration du verrouillage est l'intervalle de temps après lequel le verrou sera automatiquement libéré si aucun appel explicite n'est effectué pour libérer le verrou pendant l'intervalle de délai d'attente. Cela empêchera que vos données soient verrouillées pour une durée infinie.
Libération forcée des serrures : Des situations peuvent survenir dans des environnements distribués lorsqu'une application qui a acquis le verrou sur un élément du cache se termine brusquement ou qu'une application finalise son traitement sur des données verrouillées. Dans une telle situation, vous souhaiteriez libérer tous les verrous acquis par une telle application. NCache fournit une API de déverrouillage, qui libère de force le verrouillage des éléments du cache.
Notes
Il est recommandé d'utiliser le mécanisme de verrouillage temporel afin que l'objet soit déverrouillé une fois la condition remplie afin que les ressources restent acquises pendant le temps minimum.
Quand utiliser le verrouillage pessimiste
Prenons l’exemple évoqué dans le chapitre précédent. Si le même compte bancaire est accédé par deux utilisateurs différents au même instant pour une opération de mise à jour, un conflit peut survenir, entraînant une incohérence des données.
Le verrouillage pessimiste dans ce scénario permettra à un utilisateur d’accéder au compte à la fois. En cas de fonctionnement réussi, l'utilisateur déverrouille l'élément et le contrôle est libéré, ce qui signifie que le deuxième utilisateur peut désormais accéder au compte et faire amende honorable en conséquence.
Grâce à cette approche, les données restent cohérentes et aucun conflit ne se produit.
A LockHandle
est associé à un élément pour s'assurer que l'élément particulier reste inaccessible dans tout le cache.
NCache fournit une méthode qui appelle exclusivement le verrouillage, ainsi que de nombreuses surcharges qui manipulent le mécanisme de verrouillage.
Pré-requis
- Pour en savoir plus sur les prérequis standard requis pour travailler avec tous NCache fonctionnalités côté client, veuillez vous référer à la page donnée sur Prérequis de l'API côté client.
- Pour plus de détails sur l'API, reportez-vous à : ICache, Inclus, que vous avez, insérer, Bloquer, Poignée de verrouillage, Effacer, Durée, Débloquer.
Verrouiller un élément explicitement
Vous pouvez verrouiller explicitement un élément avant d'effectuer une opération. Cette méthode nécessite un TimeSpan
pour verrouiller un élément pendant une durée spécifiée. Cependant, si vous ne souhaitez pas que le verrou acquis expire, précisez TimeSpan.Zero
. Spécifier non TimeSpan
verrouillera l'élément pour un temps infini.
Les Lock
méthode utilisée dans cet exemple associe un LockHandle
avec une clé. Veuillez vous assurer que le single LockHandle
est associé à une seule clé. Relâchez le verrou avant de réutiliser la poignée ; sinon, cela pourrait conduire à une incohérence de comportement.
Si un élément est déjà verrouillé, la valeur fausse sera renvoyée, mais vous obtiendrez la valeur mise à jour. LockHandle
.
Verrouiller un élément pour le minimum TimeSpan
pour éviter une impasse ou un état de famine.
L'exemple suivant crée un LockHandle
puis verrouille un élément avec la clé Product:1001
pendant une période de 10 secondes, ce qui signifie que l'élément sera déverrouillé automatiquement après 10 secondes.
// Preconditions: Cache is already connected
// Item is already added in the cache
// Specify the key of the item
string key = $"Product:1001";
//Create a new LockHandle
LockHandle lockHandle = null;
// Specify time span of 10 seconds for which the item remains locked
TimeSpan lockSpan = TimeSpan.FromSeconds(10);
// Lock the item for a time span of 10 seconds
bool lockAcquired = cache.Lock(key, lockSpan, out lockHandle);
// Verify if the item is locked successfully
if (lockAcquired == true)
{
// Item has been successfully locked
}
else
{
// Key does not exist
// Item is already locked with a different LockHandle
}
Notes
Pour garantir la sécurité de l'opération, il est recommandé de gérer toutes les exceptions potentielles au sein de votre application, comme expliqué dans Gestion des échecs.
Verrouiller un élément pendant l'opération Get
Un élément peut être verrouillé lors de sa récupération depuis le cache. Cela signifie que l'élément sera inaccessible aux autres à moins que vous ne le libériez. En cas de non-concordance des clés, une valeur nulle est renvoyée.
Si un élément n'est pas verrouillé et que
acquirelock
est défini sur true, vous obtiendrez l'élément avec le LockHandle.Si un élément est verrouillé et
acquirelock
est défini sur false et si vous transmettez un LockHandle vide incorrect ou nouveau, alors unnull
value est renvoyée, mais vous obtiendrez le LockHandle qui a été utilisé pour verrouiller l'élément précédemment.Si un élément est verrouillé et
acquirelock
est défini sur false et correct LockHandle est passé qui a été précédemment utilisé pour verrouiller l'élément, alors vous obtiendrez la valeur.
Verrouillez un élément pour le TimeSpan minimum pour éviter un blocage ou une famine de threads.
Dans cet exemple, une clé et LockHandle
est spécifié pour récupérer l'objet mis en cache et le verrouiller. Vous devez spécifier true si vous devez acquérir le verrou. Ici, l'élément est verrouillé après 10 secondes, ce qui signifie que l'élément sera déverrouillé automatiquement après 10 secondes.
// Specify the key of the item
string key = $"Product:1001";
// Set acquireLock flag as true
bool acquireLock = true;
// Specify time span of 10 seconds for which the item remains locked
TimeSpan lockSpan = TimeSpan.FromSeconds(10);
//Create a new LockHandle
LockHandle lockHandle = null;
// Lock the item for a time span of 10 seconds
var result = cache.Get<Product>(key, acquireLock, lockSpan, ref lockHandle);
// Verify if the item is locked successfully
if (result != null)
{
// Item has been successfully locked
}
else
{
// Key does not exist
// Item is already locked with a different LockHandle
}
Libérer le verrouillage avec l'opération de mise à jour
Lors de la mise à jour d'un élément, vous pouvez libérer le verrou permettant à d'autres personnes d'utiliser les données mises en cache. Pour libérer avec succès l'élément verrouillé, vous devrez spécifier le LockHandle
initialement utilisé pour verrouiller l'élément.
Les
LockHandle
doit être le même que celui utilisé initialement pour verrouiller l'élément, sinon vous recevrez un message d'exception indiquant "L'élément est verrouillé".If
releaseLock
est défini sur false, vous devez toujours transmettre le bonLockhandle
pour mettre à jour l'élément.Si un élément n'est pas verrouillé, alors le
LockHandle
ainsi que lereleaseLock
ne servent à rien et sont ignorés.
L'exemple suivant verrouille un élément dans le cache, puis récupère l'élément à l'aide de l'option LockHandle
. L'élément est ensuite mis à jour puis réinséré dans le cache à l'aide du insérer API.
// Specify the key of the item
string key = $"Product:1001";
// Set acquireLock flag as true
bool acquireLock = true;
// Specify time span of 10 seconds for which the item remains locked
TimeSpan lockSpan = new TimeSpan(0, 0, 10);
// Initialize the lockHandle
LockHandle lockHandle = null;
CacheItem item = cache.GetCacheItem(key, acquireLock, lockSpan, ref lockHandle);
var product = new Product();
product = item.GetValue<Product>();
// Update the unitsinstock for the product
product.UnitsInStock = 200;
bool releaseLock = true;
// Item is already locked with a LockHandle
// Update the item and release the lock as well since releaseLock is set true
// Make sure that the LockHandle matches with the already added LockHandle
cache.Insert(key, item, null, lockHandle, releaseLock);
Libérer explicitement le verrou
Pour libérer explicitement le verrou sur un élément mis en cache précédemment verrouillé ; vous devrez préciser le LockHandle
initialement utilisé pour verrouiller l'élément.
Si la LockHandle
n'est pas enregistré, vous pouvez également utiliser une autre surcharge de Unlock
qui ne prend que la clé pour déverrouiller l'objet.
Notes
Si un invalide LockHandle
est passé, aucune exception ne sera levée mais l'élément restera verrouillé.
L'exemple suivant récupère un élément déjà verrouillé à l'aide de la propriété LockHandle
puis le déverrouille à l'aide de la Unlock
API utilisant le Lockhandle
sauvegardé auparavant.
// Specify the key of the item
string key = $"Product:1001";
// Set acquireLock flag as true
bool acquireLock = true;
// Specify time span of 10 seconds for which the item remains locked
TimeSpan lockSpan = TimeSpan.FromSeconds(10);
//Create a new LockHandle
LockHandle lockHandle = null;
Product result = cache.Get<Product>(key, acquireLock, lockSpan, ref lockHandle);
// Make sure that the item is already locked and the saved LockHandle is used
// Unlock locked item using saved LockHandle
cache.Unlock(key, lockHandle);
NCache ignorera les verrous si d'autres surcharges de Get
, Insert
et Remove
les méthodes sont appelées qui ne prennent pas ou n'utilisent pas LockHandle
.
Supprimer l'élément avec LockHandle
La méthode Remove est une méthode de base qui supprime la clé du cache et renvoie l'objet supprimé au client. Si un objet personnalisé est ajouté au cache, la méthode Remove renverra Object.
LockHandle
doit être le même que celui utilisé initialement pour verrouiller l'élément, sinon vous recevrez le message d'exception indiquant "L'élément est verrouillé".Si un élément n'est pas verrouillé, alors
LockHandle
n'est d'aucune utilité et sa validité n'est pas vérifiée.
L'exemple suivant récupère un élément précédemment verrouillé à l'aide de l'option LockHandle
puis le supprime par le fichier enregistré LockHandle
du cache à l'aide de Effacer API.
Conseil
Vous pouvez surveiller/vérifier la suppression :
- Compteur "Cache Count" dans NCache Surveiller or Compteurs de performances.
- En utilisant
cache.Contains
une fois le délai d'expiration écoulé. - En utilisant
cache.Count
avant et après avoir spécifié l'expiration.
// Specify the key of the item
string key = $"Product:1001";
// Initialize the lockHandle
LockHandle lockHandle = null;
// Set acquireLock flag as true
bool acquireLock = true;
// Specify time span of 10 seconds for which the item remains locked
TimeSpan lockSpan = TimeSpan.FromSeconds(10);
// Get the item using the lockHandle
Product result = cache.Get<Product>(key, acquireLock, lockSpan, ref lockHandle);
// Removing locked item using saved lockHandle.
cache.Remove(key, lockHandle);
// Check if item is successfully removed
if (result != null)
{
if (result is Product)
{
Product product = (Product)result;
}
}
Considération spéciale lors de l'utilisation du verrouillage d'API
NCache fournit un ensemble d'API avec et sans LockHandle
pour récupérer/mettre à jour l'élément de cache. API sans LockHandle
ignorer l'élément Verrouillage. Vous devez donc utiliser toutes les API de verrouillage pour la manipulation des données. Par exemple, si un élément est verrouillé et que vous effectuez un appel d'API de mise à jour qui ne prend pas le LockHandle
en tant que paramètre d'entrée, l'élément sera alors mis à jour dans le cache quel que soit son état de verrouillage.
Important
Lorsque vous utilisez une fonctionnalité de verrouillage, vous ne devez utiliser que les appels API qui prennent LockHandle
comme paramètres. Une API qui n'accepte pas de poignées de verrouillage peut être utilisée, mais doit être utilisée avec beaucoup de soin afin de ne pas affecter l'intégrité des données.
Notes
En cas d'expulsion/expiration, NCache ignore les verrous, ce qui signifie qu'un élément verrouillé peut être supprimé à la suite d'une expiration ou d'une expulsion.
Comportement judicieux de la topologie
- Topologie en miroir et répliquée
Dans le Miroir Topologie, pour toutes les opérations de verrouillage, un verrou est acquis sur le nœud actif, et le même LockHandle
est ensuite répliqué sur le nœud passif afin que lorsque le passif devient actif, l'élément reste verrouillé. De même, l'appel de déverrouillage est également répliqué sur le nœud Passif pour déverrouiller l'élément du nœud Passif.
Dans le Répliqué Topologie, le client est connecté à un nœud et pour toutes les opérations de verrouillage, le LockHandle
est généré qui reçoit l'opération de verrouillage du client, puis le même LockHandle
sera répliqué sur tous les autres nœuds pour la cohérence des données. De même, l'opération de déverrouillage sera également répliquée sur tous les autres nœuds.
- Topologie partitionnée et réplica de partition
Dans le Partitionné Topologie, LockHandle
est généré et existe sur le même nœud qui contient l'élément, et lors du transfert d'état LockHandle
les informations sont également transférées avec l'élément au cas où l'élément se déplacerait vers un autre nœud.
In Réplique de partition Topologie, LockHandle
est généré sur le nœud actif qui contient l'élément, et même LockHandle
est ensuite répliqué sur son réplica pour la cohérence des données et pendant le transfert d'état. LockHandle
les informations sont également transférées avec l'élément au cas où l'élément serait déplacé vers un autre nœud.
- Cache Client
Dans le Cache Client, toutes les opérations basées sur le verrouillage sont directement effectuées sur le cache cluster, ce qui signifie que LockHandle
est généré et stocké dans le cache cluster. Aucune information relative au verrouillage n'est conservée dans le cache client.
Ressources additionnelles
NCache fournit un exemple d'application pour le verrouillage d'élément activé GitHub.
Voir aussi
.RAPPORTER: Alachisoft.NCache.Runtime.Caching espace de noms.
Java: com.alachisoft.ncache.runtime.caching espace de noms.
Node.js : Cache classe.
python: ncache.runtime.caching classe.