ReaderWriterLockSlim.ExitUpgradeableReadLock Método

Definição

Namespace:

System.Threading

Assembly:

System.Threading.dll

Origem:

ReaderWriterLockSlim.cs

Reduz a contagem de recursão para o modo de upgrade e sai do modo de upgrade se a contagem resultante é 0 (zero).

public:
 void ExitUpgradeableReadLock();

public void ExitUpgradeableReadLock ();

member this.ExitUpgradeableReadLock : unit -> unit

Public Sub ExitUpgradeableReadLock ()

Exceções

SynchronizationLockException

O thread atual não entrou no bloqueio em modo de upgrade.

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.

O método mostrado no exemplo recupera o valor associado a uma chave e o compara com um novo valor. Se o valor for inalterado, o método retornará um status indicando nenhuma alteração. Se nenhum valor for encontrado para a chave, o par chave/valor será inserido. Se o valor tiver sido alterado, ele será atualizado. O modo atualizável permite que o thread atualize o bloqueio de leitura conforme necessário, sem risco de deadlocks.

O exemplo usa o construtor sem parâmetros para criar o bloqueio, portanto, a recursão não é permitida. Programar o ReaderWriterLockSlim é mais simples e menos propenso a erros quando o bloqueio não permite recursão.

Esse código faz parte de um exemplo maior fornecido para a ReaderWriterLockSlim classe .

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

Esse método não é sensível à ordem de recursão. Por exemplo, se um thread entra em um bloqueio no modo atualizável e entra no bloqueio no modo de gravação, a ordem na qual o thread sai dos dois modos não importa. Se um bloqueio permitir recursão, um thread poderá entrar no bloqueio no modo de gravação e inseri-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.

Sair do bloqueio pode sinalizar outros threads em espera.