ReaderWriterLockSlim.ExitUpgradeableReadLock Metod

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Undantag

Exempel

I följande exempel visas hur du använder ett finally block för att köra ExitUpgradeableReadLock metoden, vilket säkerställer att anroparen avslutar uppgraderingsbart läge.

Metoden som visas i exemplet hämtar värdet som är associerat med en nyckel och jämför det med ett nytt värde. Om värdet är oförändrat returnerar metoden en status som anger ingen ändring. Om inget värde hittas för nyckeln infogas nyckel/värde-paret. Om värdet har ändrats uppdateras det. Med uppgraderingsbart läge kan tråden uppgradera läslåset efter behov, utan risk för dödlägen.

I exemplet används den parameterlösa konstruktorn för att skapa låset, så rekursion tillåts inte. Programmering är ReaderWriterLockSlim enklare och mindre felbenäget när låset inte tillåter rekursion.

Den här koden är en del av ett större exempel som tillhandahålls ReaderWriterLockSlim för klassen.

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

Kommentarer

Den här metoden är inte känslig för rekursionsordning. Om en tråd till exempel går in i ett lås i uppgraderingsbart läge och sedan går in i låset i skrivläge spelar det ingen roll i vilken ordning tråden avslutar de två lägena. Om ett lås tillåter rekursion kan en tråd ange låset i skrivläge och sedan ange det rekursivt i uppgraderingsbart läge. i vilken ordning tråden avslutar uppgraderingsbart läge och skrivläge spelar ingen roll.

Om låset avslutas kan andra väntande trådar signaleras.