ReaderWriterLockSlim.EnterUpgradeableReadLock Metodo

public:
 void EnterUpgradeableReadLock();

public void EnterUpgradeableReadLock();

member this.EnterUpgradeableReadLock : unit -> unit

Public Sub EnterUpgradeableReadLock ()

Eccezioni

Esempio

Nell'esempio seguente viene illustrato come usare il EnterUpgradeableReadLock metodo per immettere il blocco in modalità aggiornabile. Un finally blocco viene usato per eseguire il ExitUpgradeableReadLock metodo, assicurandosi che il chiamante esce dalla modalità aggiornabile.

Il metodo illustrato nell'esempio recupera il valore associato a una chiave e lo confronta con un nuovo valore. Se il valore è invariato, il metodo restituisce uno stato che indica che non viene apportata alcuna modifica. Se non viene trovato alcun valore per la chiave, viene inserita la coppia chiave/valore. Se il valore è stato modificato, viene aggiornato. La modalità aggiornabile consente al thread di aggiornare il blocco di lettura in base alle esigenze, senza rischi di deadlock.

Nell'esempio viene usato il costruttore senza parametri per creare il blocco, pertanto la ricorsione non è consentita. La programmazione di ReaderWriterLockSlim è più semplice e meno soggetta a errori quando il blocco non consente la ricorsione.

Questo codice fa parte di un esempio più ampio fornito per 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

Commenti

Questo metodo blocca fino a quando il thread chiamante non entra nel blocco e pertanto potrebbe non restituire mai. Utilizzare il TryEnterUpgradeableReadLock metodo per bloccare per un intervallo specificato e quindi restituire se il thread chiamante non è entrato in modalità aggiornabile durante tale intervallo.

Usare la modalità aggiornabile quando un thread accede in genere alla risorsa protetta da ReaderWriterLockSlim in modalità di lettura, ma potrebbe essere necessario attivare la modalità di scrittura se vengono soddisfatte determinate condizioni. Un thread in modalità aggiornabile può effettuare il downgrade alla modalità di lettura o l'aggiornamento alla modalità di scrittura.

Un solo thread può entrare in modalità aggiornabile in qualsiasi momento. Se un thread è in modalità aggiornabile e non ci sono thread in attesa di entrare in modalità di scrittura, un numero qualsiasi di altri thread può entrare in modalità di lettura, anche se sono presenti thread in attesa di entrare in modalità aggiornabile.

Se uno o più thread sono in attesa di entrare in modalità di scrittura, un thread che chiama i blocchi del EnterUpgradeableReadLock metodo fino a quando tali thread non hanno superato il timeout o hanno immesso la modalità di scrittura e quindi sono usciti da esso.