ReaderWriterLockSlim.EnterUpgradeableReadLock Método

public:
 void EnterUpgradeableReadLock();

public void EnterUpgradeableReadLock();

member this.EnterUpgradeableReadLock : unit -> unit

Public Sub EnterUpgradeableReadLock ()

Exceções

Exemplos

O exemplo seguinte mostra como usar o EnterUpgradeableReadLock método para entrar na fechadura em modo atualizável. Um bloco é usado para executar o ExitUpgradeableReadLock método, garantindo que o chamador sai do finally modo atualizável.

O método mostrado no exemplo recupera o valor associado a uma chave e compara-o com um novo valor. Se o valor não for alterado, o método retornará um status indicando que não há 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 a 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.

Este código faz parte de um exemplo mais amplo fornecido para a ReaderWriterLockSlim turma.

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

Observações

Este método bloqueia até que o thread que chama entre no bloqueio e, portanto, pode nunca mais regressar. Use o TryEnterUpgradeableReadLock método para bloquear durante um intervalo especificado e depois retorne se o thread que chama não tiver entrado em modo atualizável durante esse intervalo.

Use o modo atualizável quando uma thread normalmente acede ao recurso protegido pelo ReaderWriterLockSlim modo de leitura, mas pode ser necessário entrar no modo de escrita se certas condições forem cumpridas. Um thread em modo atualizável pode fazer downgrade para modo de leitura ou para modo de escrita.

Apenas um fio pode entrar em modo atualizável em cada momento. Se uma thread estiver em modo atualizável e não houver threads à espera de entrar no modo de escrita, qualquer número de outros threads pode entrar em modo de leitura, mesmo que haja threads à espera para entrar no modo atualizável.

Se uma ou mais threads estiverem à espera de entrar em modo de escrita, uma thread que chama o EnterUpgradeableReadLock método bloqueia-se até que essas threads tenham expirado o tempo ou entrado em modo de escrita e depois saíam desse modo.