ReaderWriterLockSlim.EnterUpgradeableReadLock Método

Definição

Namespace:

System.Threading

Assembly:

System.Threading.dll

Origem:

ReaderWriterLockSlim.cs

Tenta entrar no bloqueio no modo atualizável.

public:
 void EnterUpgradeableReadLock();

public void EnterUpgradeableReadLock ();

member this.EnterUpgradeableReadLock : unit -> unit

Public Sub EnterUpgradeableReadLock ()

Exceções

LockRecursionException

A propriedade RecursionPolicy é NoRecursion e o thread atual já entrou no bloqueio em qualquer modo.

- ou -

O thread atual entrou no modo de leitura, portanto, tentar entrar no modo atualizável criará a possibilidade de um deadlock.

- ou -

O número de recursão excederia a capacidade do contador. O limite é tão grande que os aplicativos nunca o alcançariam.

ObjectDisposedException

O objeto ReaderWriterLockSlim foi descartado.

Exemplos

O exemplo a seguir mostra como usar o EnterUpgradeableReadLock método para inserir o bloqueio no modo atualizável. Um finally bloco é usado 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 não for alterado, 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. A programação do ReaderWriterLockSlim é mais simples e menos propensa a erros quando o bloqueio não permite a 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 bloqueia até que o thread de chamada insira o bloqueio e, portanto, talvez nunca retorne. Use o TryEnterUpgradeableReadLock método para bloquear um intervalo especificado e retorne se o thread de chamada não tiver entrado no modo atualizável durante esse intervalo.

Use o modo atualizável quando um thread geralmente acessa o recurso protegido pelo ReaderWriterLockSlim no modo de leitura, mas pode precisar entrar no modo de gravação se determinadas condições forem atendidas. Um thread no modo atualizável pode fazer downgrade para o modo de leitura ou atualizar para o modo de gravação.

Somente um thread pode entrar no modo atualizável a qualquer momento. Se um thread estiver no modo atualizável e não houver threads aguardando para entrar no modo de gravação, qualquer número de outros threads poderá entrar no modo de leitura, mesmo que haja threads aguardando para entrar no modo atualizável.

Se um ou mais threads estiverem aguardando para entrar no modo de gravação, um thread que chama o EnterUpgradeableReadLock método bloqueia até que esses threads tenham cronometrado ou inserido no modo de gravação e, em seguida, saído dele.

Observação

Se um bloqueio permitir recursão, um thread que inseriu o bloqueio no modo atualizável poderá entrar no modo atualizável recursivamente, mesmo que outros threads estejam aguardando para entrar no modo de gravação.