ReaderWriterLockSlim.ExitUpgradeableReadLock Metoda

Definicja

Przestrzeń nazw:

System.Threading

Zestaw:

System.Threading.dll

Źródło:

ReaderWriterLockSlim.cs

Zmniejsza liczbę rekursji dla trybu uaktualniania i kończy tryb uaktualniania, jeśli wynikowa liczba wynosi 0 (zero).

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock ();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Wyjątki

SynchronizationLockException

Bieżący wątek nie wprowadził blokady w trybie uaktualniania.

Przykłady

W poniższym przykładzie pokazano, jak użyć finally bloku do wykonania ExitUpgradeableReadLock metody, upewniając się, że obiekt wywołujący kończy tryb uaktualniania.

Metoda pokazana w przykładzie pobiera wartość skojarzona z kluczem i porównuje ją z nową wartością. Jeśli wartość jest niezmieniona, metoda zwraca stan wskazujący brak zmian. Jeśli dla klucza nie zostanie znaleziona żadna wartość, zostanie wstawiona para klucz/wartość. Jeśli wartość została zmieniona, zostanie ona zaktualizowana. Tryb uaktualniania umożliwia wątkowi uaktualnienie blokady odczytu zgodnie z potrzebami bez ryzyka zakleszczenia.

W przykładzie użyto konstruktora bez parametrów do utworzenia blokady, więc rekursja nie jest dozwolona. Programowanie jest ReaderWriterLockSlim prostsze i mniej podatne na błąd, gdy blokada nie zezwala na rekursję.

Ten kod jest częścią większego przykładu udostępnionego ReaderWriterLockSlim dla klasy .

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

Uwagi

Ta metoda nie jest wrażliwa na kolejność rekursji. Jeśli na przykład wątek wejdzie do blokady w trybie uaktualniania, a następnie wprowadzi blokadę w trybie zapisu, kolejność, w której wątek kończy działanie tych dwóch trybów, nie ma znaczenia. Jeśli blokada zezwala na rekursję, wątek może wprowadzić blokadę w trybie zapisu, a następnie wprowadzić go rekursywnie w trybie uaktualniania; kolejność, w jakiej wątek kończy tryb uaktualniania, a tryb zapisu nie ma znaczenia.

Wyjście z blokady może sygnalizuje inne wątki oczekujące.