LockRecursionPolicy Enumeración
TOC
Collapse the table of content
Expand the table of content

LockRecursionPolicy (Enumeración)

 

Especifica si el mismo subproceso puede entrar varias veces en un bloqueo.

Espacio de nombres:   System.Threading
Ensamblado:  System.Core (en System.Core.dll)

public enum LockRecursionPolicy

Nombre de miembroDescripción
NoRecursion

Si un subproceso intenta entrar en un bloqueo de forma recursiva, se inicia una excepción.Algunas clases pueden permitir cierta recursividad cuando se aplica esta configuración.

SupportsRecursion

Un subproceso puede entrar en un bloqueo de forma recursiva.Algunas clases pueden limitar esta posibilidad.

La directiva de recursividad predeterminada depende del tipo de bloqueo.Para conocer la directiva predeterminada y el comportamiento preciso de recursividad de bloqueo para cualquier tipo de bloqueo determinado, consulte la documentación referente al tipo.Por ejemplo, la clase ReaderWriterLockSlim no permite que un subproceso entre en el bloqueo en modo de escritura si ya entró en el bloqueo en modo de lectura, sin tener en cuenta el valor de la directiva de bloqueo, para reducir la posibilidad de interbloqueos.

Actualmente sólo un bloqueo utiliza esta enumeración:

El ejemplo siguiente muestra dos escenarios de excepción, uno que depende del valor LockRecursionPolicy y otro que no.

En el primer escenario, el subproceso entra en el bloqueo en modo de lectura y, a continuación, intenta entrar en modo de lectura de forma recursiva.Si ReaderWriterLockSlim se crea utilizando el constructor predeterminado, que establece la directiva de recursividad en NoRecursion, se produce una excepción.Si se usa SupportsRecursion para crear ReaderWriterLockSlim, no se inicia ninguna excepción.

En el segundo escenario, el subproceso entra en el bloqueo en modo de lectura y, a continuación, intenta entrar en el bloqueo en modo de escritura.Se produce una excepción LockRecursionException sin tener en cuenta la directiva de recursividad de bloqueo.

using System;
using System.Threading;

class Example
{
    // By default, the lock recursion policy for a new 
    // ReaderWriterLockSlim does not allow recursion.
    private static ReaderWriterLockSlim rwls = new ReaderWriterLockSlim();
    private static ReaderWriterLockSlim rwlsWithRecursion =
        new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);

    static void ThreadProc()
    { 
        Console.WriteLine("1. Enter the read lock recursively.");
        ReadRecursive(rwls);
        ReadRecursive(rwlsWithRecursion);

        Console.WriteLine("\n2. Enter the write lock recursively from the read lock.");
        ReadWriteRecursive(rwls);
        ReadWriteRecursive(rwlsWithRecursion);
    } 

    static void ReadRecursive(ReaderWriterLockSlim rwls)
    {
        Console.WriteLine("LockRecursionPolicy.{0}:", rwls.RecursionPolicy);
        rwls.EnterReadLock();

        try {
            rwls.EnterReadLock();
            Console.WriteLine("\nThe read lock was entered recursively.");
            rwls.ExitReadLock();
        }    
        catch (LockRecursionException lre) {
            Console.WriteLine("\n{0}: {1}",
                lre.GetType().Name, lre.Message);
        }

        rwls.ExitReadLock();
    }

    static void ReadWriteRecursive(ReaderWriterLockSlim rwls)
    {
        Console.WriteLine("LockRecursionPolicy.{0}:", rwls.RecursionPolicy);
        rwls.EnterReadLock();

        try {
            rwls.EnterWriteLock();
            Console.WriteLine("\nThe write lock was entered recursively.");
        }
        catch (LockRecursionException lre) {
            Console.WriteLine("\n{0}: {1}", 
                lre.GetType().Name, lre.Message);
        }

        rwls.ExitReadLock();
    }

    static void Main() 
    {
        Thread t = new Thread(ThreadProc);
        t.Start();
        t.Join();

        // Dispose of ReaderWriterLockSlim objects' unmanaged resources.
        if (rwls != null) rwls.Dispose();
        if (rwlsWithRecursion != null) rwlsWithRecursion.Dispose();
    } 
} 
// This example displays output similar to the following:
//    1. Enter the read lock recursively.
//    LockRecursionPolicy.NoRecursion:
//    
//    LockRecursionException: Recursive read lock acquisitions not allowed in this mode.
//    LockRecursionPolicy.SupportsRecursion:
//    
//    The read lock was entered recursively.
//    
//    2. Enter the write lock recursively from the read lock.
//    LockRecursionPolicy.NoRecursion:
//    
//    LockRecursionException: Write lock may not be acquired with read lock held. This pattern i
//    s prone to deadlocks. Please ensure that read locks are released before taking a write loc
//    k. If an upgrade is necessary, use an upgrade lock in place of the read lock.
//    LockRecursionPolicy.SupportsRecursion:
//    
//    LockRecursionException: Write lock may not be acquired with read lock held. This pattern i
//    s prone to deadlocks. Please ensure that read locks are released before taking a write loc
//    k. If an upgrade is necessary, use an upgrade lock in place of the read lock.

Universal Windows Platform
Disponible desde 4.5
.NET Framework
Disponible desde 3.5
Portable Class Library
Compatible con: portable .NET platforms
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar:
© 2016 Microsoft