ReaderWriterLockSlim.ExitUpgradeableReadLock Metódus

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.dll

Forrás:

ReaderWriterLockSlim.cs

Csökkenti a frissíthető mód rekurziós számát, és kilép a frissíthető módból, ha az eredményül kapott szám 0 (nulla).

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Kivételek

SynchronizationLockException

Az aktuális szál nem lett frissíthető módban belépve a zárolásba.

Példák

Az alábbi példa bemutatja, hogyan lehet blokkot finally használni a ExitUpgradeableReadLock metódus végrehajtásához, biztosítva, hogy a hívó kilépjen a frissíthető módból.

A példában látható metódus lekéri a kulcshoz társított értéket, és összehasonlítja egy új értékkel. Ha az érték nem változik, a metódus olyan állapotot ad vissza, amely nem változik. Ha nem található érték a kulcshoz, a rendszer beszúrja a kulcsot/értékpárt. Ha az érték megváltozott, az frissül. A frissíthető mód lehetővé teszi, hogy a szál szükség szerint frissítse az olvasási zárat, holtpontok veszélye nélkül.

A példa a paraméter nélküli konstruktort használja a zárolás létrehozásához, ezért a rekurzió nem engedélyezett. A programozás ReaderWriterLockSlim egyszerűbb és kevésbé hajlamos a hibákra, ha a zárolás nem teszi lehetővé a rekurziót.

Ez a kód egy nagyobb, az ReaderWriterLockSlim osztályhoz tartozó példa része.

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

Megjegyzések

Ez a módszer nem érzékeny a rekurziós sorrendre. Ha például egy szál frissíthető módban lép be egy zárba, majd írási módban adja meg a zárolást, az a sorrend, amelyben a szál kilép a két módból, nem számít. Ha a zárolás lehetővé teszi a rekurziót, a szálak írási módban léphetnek be a zárolásba, majd rekurzívan, frissíthető módban léphetnek be; az a sorrend, amelyben a szál kilép a frissíthető módból és az írási módból, nem számít.

A zárolásból való kilépés más várakozási szálakat is jelezhet.