ReaderWriterLockSlim.EnterUpgradeableReadLock Método

public:
 void EnterUpgradeableReadLock();

public void EnterUpgradeableReadLock ();

member this.EnterUpgradeableReadLock : unit -> unit

Public Sub EnterUpgradeableReadLock ()

Excepciones

Ejemplos

En el ejemplo siguiente se muestra cómo usar el EnterUpgradeableReadLock método para especificar el bloqueo en modo actualizable. Un finally bloque se usa para ejecutar el ExitUpgradeableReadLock método , asegurándose de que el autor de la llamada sale del modo actualizable.

El método que se muestra en el ejemplo recupera el valor asociado a una clave y lo compara con un nuevo valor. Si el valor no cambia, el método devuelve un estado que indica ningún cambio. Si no se encuentra ningún valor para la clave, se inserta el par clave-valor. Si el valor ha cambiado, se actualiza. El modo actualizable permite al subproceso actualizar el bloqueo de lectura según sea necesario, sin riesgo de interbloqueos.

En el ejemplo se usa el constructor sin parámetros para crear el bloqueo, por lo que no se permite la recursividad. ReaderWriterLockSlim La programación es más sencilla y menos propensa a errores cuando el bloqueo no permite la recursividad.

Este código forma parte de un ejemplo más grande proporcionado para la ReaderWriterLockSlim clase .

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

Comentarios

Este método se bloquea hasta que el subproceso que realiza la llamada entra en el bloqueo y, por tanto, es posible que nunca vuelva. Use el TryEnterUpgradeableReadLock método para bloquear un intervalo especificado y, a continuación, devuelva si el subproceso que realiza la llamada no ha entrado en modo actualizable durante ese intervalo.

Use el modo actualizable cuando un subproceso tenga acceso normalmente al recurso protegido por en ReaderWriterLockSlim modo de lectura, pero es posible que tenga que entrar en modo de escritura si se cumplen determinadas condiciones. Un subproceso en modo actualizable puede degradarse al modo de lectura o actualizar al modo de escritura.

Solo un subproceso puede entrar en modo actualizable en un momento dado. Si un subproceso está en modo actualizable y no hay subprocesos que esperan entrar en modo de escritura, cualquier número de otros subprocesos puede entrar en modo de lectura, incluso si hay subprocesos que esperan entrar en modo actualizable.

Si uno o varios subprocesos están esperando entrar en modo de escritura, un subproceso que llama al EnterUpgradeableReadLock método se bloquea hasta que esos subprocesos hayan agotado el tiempo de espera o hayan entrado en modo de escritura y, a continuación, salgan de él.

Se aplica a