ReaderWriterLockSlim.EnterUpgradeableReadLock Methode

public:
 void EnterUpgradeableReadLock();

public void EnterUpgradeableReadLock();

member this.EnterUpgradeableReadLock : unit -> unit

Public Sub EnterUpgradeableReadLock ()

Ausnahmen

Beispiele

Das folgende Beispiel zeigt, wie Sie die EnterUpgradeableReadLock Methode verwenden, um die Sperre im upgradefähigen Modus einzugeben. Ein finally Block wird verwendet, um die ExitUpgradeableReadLock Methode auszuführen, um sicherzustellen, dass der Aufrufer den upgradefähigen Modus beendet.

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. Im upgradefähigen Modus kann der Thread die Lesesperre nach Bedarf aktualisieren, ohne dass Deadlocks riskieren.

Im Beispiel wird der parameterlose Konstruktor zum Erstellen der Sperre verwendet, sodass rekursion nicht zulässig ist. Die ReaderWriterLockSlim Programmierung ist einfacher und weniger anfällig für Fehler, wenn die Sperre keine Rekursion zulässt.

Dieser Code ist Teil eines größeren Beispiels, das für die ReaderWriterLockSlim Klasse bereitgestellt wird.

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 blockiert, bis der aufrufende Thread die Sperre eingibt und daher möglicherweise nie zurückgegeben wird. Verwenden Sie die TryEnterUpgradeableReadLock Methode, um für ein angegebenes Intervall zu blockieren, und geben Sie dann zurück, wenn der aufrufende Thread während dieses Intervalls keinen upgradefähigen Modus eingegeben hat.

Verwenden Sie den upgradefähigen Modus, wenn ein Thread in der Regel auf die Ressource zugreift, die ReaderWriterLockSlim im Lesemodus geschützt ist, aber möglicherweise in den Schreibmodus wechseln muss, wenn bestimmte Bedingungen erfüllt sind. Ein Thread im upgradefähigen Modus kann in den Lesemodus herabstufen oder auf den Schreibmodus aktualisieren.

Es kann jeweils nur ein Thread in den Upgrademodus wechseln. Wenn sich ein Thread im upgradefähigen Modus befindet und es keine Threads gibt, die auf den Schreibmodus warten, kann eine beliebige Anzahl anderer Threads in den Lesemodus wechseln, auch wenn Threads vorhanden sind, die auf den Upgrademodus warten.

Wenn mindestens ein Threads darauf wartet, in den Schreibmodus zu wechseln, wird ein Thread, der die EnterUpgradeableReadLock Methodenblöcke aufruft, bis diese Threads entweder einen Timeout oder einen Schreibmodus überschritten haben und dann von ihr beendet wurden.