LockRecursionPolicy Enumeración

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Threading.dll

Ensamblado:

System.Core.dll

Ensamblado:

netstandard.dll

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

C#

public enum LockRecursionPolicy

Herencia

Object

ValueType

Enum

LockRecursionPolicy

Campos

NoRecursion	0	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	1	Un subproceso puede entrar en un bloqueo de forma recursiva. Algunas clases pueden limitar esta posibilidad.

Ejemplos

En el ejemplo siguiente se muestran dos escenarios de excepción, uno que depende de la LockRecursionPolicy configuración y uno que no lo hace.

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. ReaderWriterLockSlim Si se crea mediante el constructor sin parámetros, que establece la directiva de recursividad en NoRecursion, se produce una excepción. Si SupportsRecursion se usa para crear , ReaderWriterLockSlimno se produce 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. LockRecursionException se produce independientemente de la directiva de recursividad de bloqueo.

C#

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.

Comentarios

La directiva de recursividad predeterminada depende del tipo de bloqueo. Para obtener la directiva predeterminada y el comportamiento preciso de la recursividad de bloqueo para cualquier tipo de bloqueo determinado, consulte la documentación del tipo. Por ejemplo, la ReaderWriterLockSlim clase no permite que un subproceso entre en el modo de escritura si ya ha entrado en el bloqueo en modo de lectura, independientemente de la configuración de directiva de bloqueo, para reducir la posibilidad de interbloqueos.

Actualmente, solo un bloqueo usa esta enumeración:

• ReaderWriterLockSlim. Para obtener más información, vea la propiedad RecursionPolicy.

Se aplica a