ReaderWriterLockSlim.ExitUpgradeableReadLock Methode

Definition

Namespace:

System.Threading

Assembly:

System.Threading.dll

Quelle:

ReaderWriterLockSlim.cs

Verringert die Rekursionszahl für den erweiterbaren Modus und beendet den erweiterbaren Modus, wenn das Rekursionsergebnis 0 (null) ist.

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock ();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Ausnahmen

SynchronizationLockException

Der aktuelle Thread befindet sich nicht im erweiterbaren Modus.

Beispiele

Das folgende Beispiel zeigt, wie Sie einen finally -Block verwenden, um die ExitUpgradeableReadLock -Methode auszuführen, um sicherzustellen, dass der Aufrufer den upgradefähigen Modus verlässt.

Die im Beispiel gezeigte Methode ruft den einem Schlüssel zugeordneten Wert ab und vergleicht ihn mit einem neuen Wert. Wenn der Wert unverändert ist, gibt die Methode einen status zurück, der keine Änderung angibt. Wenn kein Wert für den Schlüssel gefunden wird, wird das Schlüssel-Wert-Paar eingefügt. Wenn sich der Wert geändert hat, wird er aktualisiert. Der upgradebare Modus ermöglicht es dem Thread, die Lesesperre nach Bedarf zu aktualisieren, ohne das Risiko von Deadlocks.

Im Beispiel wird der parameterlose Konstruktor verwendet, um die Sperre zu erstellen, sodass die Rekursion nicht zulässig ist. Das Programmieren von ReaderWriterLockSlim ist einfacher und weniger fehleranfällig, wenn die Sperre keine Rekursion zulässt.

Dieser Code ist Teil eines größeren Beispiels für die ReaderWriterLockSlim -Klasse.

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

Hinweise

Diese Methode ist nicht empfindlich auf die Rekursionsreihenfolge. Wenn beispielsweise ein Thread im upgradefähigen Modus in eine Sperre wechselt und dann im Schreibmodus in die Sperre wechselt, spielt die Reihenfolge, in der der Thread die beiden Modi verlässt, keine Rolle. Wenn eine Sperre die Rekursion zulässt, kann ein Thread im Schreibmodus in die Sperre wechseln und sie dann rekursiv im upgradefähigen Modus eingeben. Die Reihenfolge, in der der Thread den upgradefähigen Modus und den Schreibmodus verlässt, spielt keine Rolle.

Das Beenden der Sperre kann anderen wartenden Threads signalisieren.