ReaderWriterLockSlim.EnterUpgradeableReadLock Méthode

Définition

Espace de noms:

System.Threading

Assembly:

System.Threading.dll

Source:

ReaderWriterLockSlim.cs

Essaie d'entrer le verrou en mode pouvant être mis à niveau.

public:
 void EnterUpgradeableReadLock();

public void EnterUpgradeableReadLock ();

member this.EnterUpgradeableReadLock : unit -> unit

Public Sub EnterUpgradeableReadLock ()

Exceptions

LockRecursionException

La propriété RecursionPolicy est NoRecursion et le thread actuel a déjà entré le verrou dans un mode quelconque.

- ou -

Le thread actuel est entré en mode lecture, et une tentative d'entrer en mode de mise à niveau risquerait de créer un interblocage.

- ou -

Le nombre de récursivités dépasserait la capacité du compteur. Cette limite est si élevée que les applications ne doivent jamais la rencontrer.

ObjectDisposedException

L’objet ReaderWriterLockSlim a été supprimé.

Exemples

L’exemple suivant montre comment utiliser la EnterUpgradeableReadLock méthode pour entrer le verrou en mode pouvant être mis à niveau. Un finally bloc est utilisé pour exécuter la ExitUpgradeableReadLock méthode, ce qui garantit que l’appelant quitte le mode pouvant être mis à niveau.

La méthode présenté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 qu’aucune modification n’est apportée. 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 pouvant être mis à niveau permet au thread de mettre à niveau le verrou de lecture en fonction des besoins, sans risque d’interblocage.

L’exemple utilise le constructeur sans paramètre pour créer le verrou, de sorte que la récursivité n’est pas autorisée. La programmation est ReaderWriterLockSlim 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 se bloque jusqu’à ce que le thread appelant entre dans le verrou et peut donc ne jamais revenir. Utilisez la TryEnterUpgradeableReadLock méthode pour bloquer pendant un intervalle spécifié, puis retournez si le thread appelant n’est pas entré en mode de mise à niveau pendant cet intervalle.

Utilisez le mode pouvant être mis à niveau lorsqu’un thread accède généralement à la ressource protégée par le ReaderWriterLockSlim en mode lecture, mais peut avoir besoin d’entrer en mode écriture si certaines conditions sont remplies. Un thread en mode pouvant être mis à niveau peut passer en mode lecture ou passer en mode écriture.

Un seul thread peut passer en mode pouvant être mis à niveau à un moment donné. Si un thread est en mode pouvant être mis à niveau et qu’aucun thread n’attend d’entrer en mode écriture, n’importe quel nombre d’autres threads peuvent passer en mode lecture, même s’il y a des threads en attente d’entrer en mode pouvant être mis à niveau.

Si un ou plusieurs threads attendent d’entrer en mode écriture, un thread qui appelle la EnterUpgradeableReadLock méthode se bloque jusqu’à ce que ces threads aient expiré ou entré en mode écriture, puis s’en sont retirés.

Notes

Si un verrou autorise la récursivité, un thread qui est entré dans le verrou en mode pouvant être mis à niveau peut passer en mode pouvant être mis à niveau de manière récursive, même si d’autres threads attendent d’entrer en mode écriture.