ReaderWriterLockSlim.ExitUpgradeableReadLock Metoda

Definice

Obor názvů:

System.Threading

Sestavení:

System.Threading.dll

Zdroj:

ReaderWriterLockSlim.cs

Snižuje počet rekurzí pro upgradovatelný režim a ukončí upgradovatelný režim, pokud je výsledný počet 0 (nula).

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock ();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Výjimky

SynchronizationLockException

Aktuální vlákno nevstoupilo do zámku v upgradovatelném režimu.

Příklady

Následující příklad ukazuje, jak použít finally blok ke spuštění ExitUpgradeableReadLock metody, čímž se zajistí, že volající ukončí upgradovatelný režim.

Metoda zobrazená v příkladu načte hodnotu přidruženou ke klíči a porovná ji s novou hodnotou. Pokud je hodnota beze změny, vrátí metoda stav označující beze změny. Pokud se pro klíč nenajde žádná hodnota, vloží se pár klíč-hodnota. Pokud se hodnota změnila, aktualizuje se. Upgradovatelný režim umožňuje vláknu upgradovat zámek čtení podle potřeby bez rizika zablokování.

V příkladu se k vytvoření zámku používá konstruktor bez parametrů, takže rekurze není povolená. ReaderWriterLockSlim Programování je jednodušší a méně náchylné k chybám, pokud zámek neumožňuje rekurze.

Tento kód je součástí většího příkladu ReaderWriterLockSlim , který je k dispozici pro třídu.

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

Poznámky

Tato metoda není citlivá na pořadí rekurze. Pokud například vlákno přejde do zámku v upgradovatelném režimu a pak přejde do zámku v režimu zápisu, nezáleží na pořadí, ve kterém vlákno ukončí oba režimy. Pokud zámek umožňuje rekurze, vlákno může vstoupit do zámku v režimu zápisu a poté jej zadat rekurzivně v upgradovatelném režimu; pořadí, ve kterém vlákno ukončí upgradovatelný režim a režim zápisu, nezáleží.

Ukončení zámku může signalizovat další čekající vlákna.