ReaderWriterLockSlim.ExitUpgradeableReadLock Método

Definição

Reduz a contagem de recursão para o modo de upgrade e sai do modo de upgrade se a contagem resultante é 0 (zero).Reduces the recursion count for upgradeable mode, and exits upgradeable mode if the resulting count is 0 (zero).

public:
 void ExitUpgradeableReadLock();
public void ExitUpgradeableReadLock ();
member this.ExitUpgradeableReadLock : unit -> unit
Public Sub ExitUpgradeableReadLock ()

Exceções

O thread atual não entrou no bloqueio em modo de upgrade.The current thread has not entered the lock in upgradeable mode.

Exemplos

O exemplo a seguir mostra como usar um finally bloco para executar o ExitUpgradeableReadLock método, garantindo que o chamador saia do modo atualizável.The following example shows how to use a finally block to execute the ExitUpgradeableReadLock method, ensuring that the caller exits upgradeable mode.

O método mostrado no exemplo recupera o valor associado a uma chave e o compara com um novo valor.The method shown in the example retrieves the value associated with a key and compares it with a new value. Se o valor for inalterado, o método retornará um status indicando que não há alteração.If the value is unchanged, the method returns a status indicating no change. Nenhum valor é encontrado para a chave, o par chave/valor é inserido.It no value is found for the key, the key/value pair is inserted. Se o valor tiver sido alterado, ele será atualizado.If the value has changed, it is updated. O modo atualizável permite que o thread atualize o bloqueio de leitura conforme necessário, sem risco de deadlocks.Upgradeable mode allows the thread to upgrade the read lock as needed, without risk of deadlocks.

O exemplo usa o construtor sem parâmetros para criar o bloqueio, portanto, a recursão não é permitida.The example uses the parameterless constructor to create the lock, so recursion is not allowed. A programação do ReaderWriterLockSlim é mais simples e menos propenso a erros quando o bloqueio não permite recursão.Programming the ReaderWriterLockSlim is simpler and less prone to error when the lock does not allow recursion.

Esse código é parte de um exemplo maior fornecido para a ReaderWriterLockSlim classe.This code is part of a larger example provided for the ReaderWriterLockSlim class.

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

Comentários

Este método não é sensível à ordem de recursão.This method is not sensitive to recursion order. Por exemplo, se um thread entrar em um bloqueio no modo atualizável e, em seguida, inserir o bloqueio no modo de gravação, a ordem na qual o thread sai dos dois modos não importa.For example, if a thread enters a lock in upgradeable mode and then enters the lock in write mode, the order in which the thread exits the two modes does not matter. Se um bloqueio permitir a recursão, um thread poderá inserir o bloqueio no modo de gravação e, em seguida, digitá-lo recursivamente no modo atualizável; a ordem na qual o thread sai do modo atualizável e o modo de gravação não importa.If a lock allows recursion, a thread can enter the lock in write mode and then enter it recursively in upgradeable mode; the order in which the thread exits upgradeable mode and write mode does not matter.

Sair do bloqueio pode sinalizar outros threads em espera.Exiting the lock might signal other waiting threads.

Aplica-se a