LockRecursionPolicy Enumeração

Definição

Namespace:

System.Threading

Assemblies:

netstandard.dll, System.Threading.dll

Especifica se um bloqueio pode ser inserido várias vezes pelo mesmo thread.

C#

public enum LockRecursionPolicy

Herança

Object

ValueType

Enum

LockRecursionPolicy

Campos

Nome	Valor	Description
NoRecursion	0	Se um thread tentar inserir um bloqueio recursivamente, uma exceção será lançada. Algumas classes podem permitir determinadas recursões quando essa configuração está em vigor.
SupportsRecursion	1	Um thread pode inserir um bloqueio recursivamente. Algumas classes podem restringir essa funcionalidade.

Exemplos

O exemplo a seguir mostra dois cenários de exceção, um que depende da LockRecursionPolicy configuração e outro que não.

No primeiro cenário, o thread entra no bloqueio no modo de leitura e tenta entrar no modo de leitura recursivamente. Se o ReaderWriterLockSlim for criado usando o construtor sem parâmetros, que define a política de recursão como NoRecursion, uma exceção será gerada. Se SupportsRecursion for usado para criar o ReaderWriterLockSlim, nenhuma exceção será gerada.

No segundo cenário, o thread entra no bloqueio no modo de leitura e tenta inserir o bloqueio no modo de gravação. LockRecursionException é gerado independentemente da política de recursão de bloqueio.

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.

Comentários

A política de recursão padrão depende do tipo de bloqueio. Para obter a política padrão e o comportamento preciso da recursão de bloqueio para qualquer tipo de bloqueio fornecido, consulte a documentação do tipo. Por exemplo, a ReaderWriterLockSlim classe não permitirá que um thread insira o bloqueio no modo de gravação se ele já tiver inserido o bloqueio no modo de leitura, independentemente da configuração da política de bloqueio, a fim de reduzir a chance de deadlocks.

Atualmente, apenas um bloqueio usa essa enumeração:

• ReaderWriterLockSlim. Para obter mais informações, consulte a propriedade RecursionPolicy.

Aplica-se a