ReaderWriterLockSlim.EnterUpgradeableReadLock Método
Definição
Tenta entrar no bloqueio no modo atualizável.Tries to enter the lock in upgradeable mode.
public:
void EnterUpgradeableReadLock();
public void EnterUpgradeableReadLock ();
member this.EnterUpgradeableReadLock : unit -> unit
Public Sub EnterUpgradeableReadLock ()
Exceções
A propriedade RecursionPolicy é NoRecursion e o thread atual já entrou no bloqueio em qualquer modo.The RecursionPolicy property is NoRecursion and the current thread has already entered the lock in any mode.
- ou --or- O thread atual entrou no modo de leitura, portanto, tentar entrar no modo atualizável criará a possibilidade de um deadlock.The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock.
- ou --or- O número de recursão excederia a capacidade do contador.The recursion number would exceed the capacity of the counter. O limite é tão grande que os aplicativos nunca o alcançariam.The limit is so large that applications should never encounter it.
O objeto ReaderWriterLockSlim foi descartado.The ReaderWriterLockSlim object has been disposed.
Exemplos
O exemplo a seguir mostra como usar o EnterUpgradeableReadLock método para inserir o bloqueio no modo atualizável.The following example shows how to use the EnterUpgradeableReadLock method to enter the lock in upgradeable mode. Um finally bloco é usado para executar o ExitUpgradeableReadLock método, garantindo que o chamador saia do modo atualizável.A finally block is used 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
Esse método é bloqueado até que o thread de chamada Insira o bloqueio e, portanto, talvez nunca retorne.This method blocks until the calling thread enters the lock, and therefore might never return. Use o TryEnterUpgradeableReadLock método a ser bloqueado para um intervalo especificado e, em seguida, retorne se o thread de chamada não tiver inserido o modo atualizável durante esse intervalo.Use the TryEnterUpgradeableReadLock method to block for a specified interval, and then return if the calling thread has not entered upgradeable mode during that interval.
Use o modo atualizável quando um thread geralmente acessa o recurso protegido pelo ReaderWriterLockSlim no modo de leitura, mas talvez precise entrar no modo de gravação se determinadas condições forem atendidas.Use upgradeable mode when a thread usually accesses the resource that is protected by the ReaderWriterLockSlim in read mode, but may need to enter write mode if certain conditions are met. Um thread no modo atualizável pode fazer downgrade para o modo de leitura ou atualizar para o modo de gravação.A thread in upgradeable mode can downgrade to read mode or upgrade to write mode.
Somente um thread pode entrar no modo atualizável em um determinado momento.Only one thread can enter upgradeable mode at any given time. 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 se houver threads aguardando para entrar no modo atualizável.If a thread is in upgradeable mode, and there are no threads waiting to enter write mode, any number of other threads can enter read mode, even if there are threads waiting to enter upgradeable mode.
Se um ou mais threads estiverem aguardando para entrar no modo de gravação, um thread que chama o EnterUpgradeableReadLock método é bloqueado até que esses threads tenham expirado ou o modo de gravação seja inserido e, em seguida, saiu dele.If one or more threads are waiting to enter write mode, a thread that calls the EnterUpgradeableReadLock method blocks until those threads have either timed out or entered write mode and then exited from it.
Observação
Se um bloqueio permitir a 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.If a lock allows recursion, a thread that has entered the lock in upgradeable mode can enter upgradeable mode recursively, even if other threads are waiting to enter write mode.