ReaderWriterLockSlim.ExitUpgradeableReadLock Méthode

Définition

Espace de noms:

System.Threading

Assembly:

System.Threading.dll

Source:

ReaderWriterLockSlim.cs

Réduit le nombre de récurrences pour le mode pouvant être mis à niveau, et quitte le mode pouvant être mis à niveau si le nombre résultant est 0 (zéro).

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock ();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Exceptions

SynchronizationLockException

Le thread actuel n'a pas entré le verrou en mode de mise à niveau.

Exemples

L’exemple suivant montre comment utiliser un finally bloc pour exécuter la ExitUpgradeableReadLock méthode, en veillant à ce que l’appelant quitte le mode mise à niveau.

La méthode indiquée dans l’exemple récupère la valeur associée à une clé et la compare à une nouvelle valeur. Si la valeur est inchangée, la méthode retourne une status indiquant aucune modification. Si aucune valeur n’est trouvée pour la clé, la paire clé/valeur est insérée. Si la valeur a changé, elle est mise à jour. Le mode mise à niveau permet au thread de mettre à niveau le verrou de lecture en fonction des besoins, sans risque d’interblocages.

L’exemple utilise le constructeur sans paramètre pour créer le verrou. La récursivité n’est donc pas autorisée. ReaderWriterLockSlim La programmation est plus simple et moins sujette aux erreurs lorsque le verrou n’autorise pas la récursivité.

Ce code fait partie d’un exemple plus large fourni pour la ReaderWriterLockSlim classe .

private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim();
private Dictionary<int, string> innerCache = new Dictionary<int, string>();

Private cacheLock As New ReaderWriterLockSlim()
Private innerCache As New Dictionary(Of Integer, String)

public AddOrUpdateStatus AddOrUpdate(int key, string value)
{
    cacheLock.EnterUpgradeableReadLock();
    try
    {
        string result = null;
        if (innerCache.TryGetValue(key, out result))
        {
            if (result == value)
            {
                return AddOrUpdateStatus.Unchanged;
            }
            else
            {
                cacheLock.EnterWriteLock();
                try
                {
                    innerCache[key] = value;
                }
                finally
                {
                    cacheLock.ExitWriteLock();
                }
                return AddOrUpdateStatus.Updated;
            }
        }
        else
        {
            cacheLock.EnterWriteLock();
            try
            {
                innerCache.Add(key, value);
            }
            finally
            {
                cacheLock.ExitWriteLock();
            }
            return AddOrUpdateStatus.Added;
        }
    }
    finally
    {
        cacheLock.ExitUpgradeableReadLock();
    }
}

Public Function AddOrUpdate(ByVal key As Integer, _
                            ByVal value As String) As AddOrUpdateStatus
    cacheLock.EnterUpgradeableReadLock()
    Try
        Dim result As String = Nothing
        If innerCache.TryGetValue(key, result) Then
            If result = value Then
                Return AddOrUpdateStatus.Unchanged
            Else
                cacheLock.EnterWriteLock()
                Try
                    innerCache.Item(key) = value
                Finally
                    cacheLock.ExitWriteLock()
                End Try
                Return AddOrUpdateStatus.Updated
            End If
        Else
            cacheLock.EnterWriteLock()
            Try
                innerCache.Add(key, value)
            Finally
                cacheLock.ExitWriteLock()
            End Try
            Return AddOrUpdateStatus.Added
        End If
    Finally
        cacheLock.ExitUpgradeableReadLock()
    End Try
End Function

public enum AddOrUpdateStatus
{
    Added,
    Updated,
    Unchanged
};

Public Enum AddOrUpdateStatus
    Added
    Updated
    Unchanged
End Enum

Remarques

Cette méthode n’est pas sensible à l’ordre de récursivité. Par exemple, si un thread entre dans un verrou en mode pouvant être mis à niveau, puis entre dans le verrou en mode écriture, l’ordre dans lequel le thread quitte les deux modes n’a pas d’importance. Si un verrou autorise la récursivité, un thread peut entrer le verrou en mode écriture, puis l’entrer de manière récursive en mode pouvant être mis à niveau ; l’ordre dans lequel le thread quitte le mode pouvant être mis à niveau et le mode d’écriture n’a pas d’importance.

La sortie du verrou peut signaler d’autres threads en attente.