LockRecursionPolicy 열거형

정의

동일한 스레드에서 잠금을 여러 번 시작할 수 있는지 여부를 지정합니다.Specifies whether a lock can be entered multiple times by the same thread.

public enum class LockRecursionPolicy
public enum LockRecursionPolicy
type LockRecursionPolicy = 
Public Enum LockRecursionPolicy
상속
LockRecursionPolicy

필드

NoRecursion 0

스레드에서 잠금을 재귀적으로 시작하려고 하면 예외가 throw됩니다.If a thread tries to enter a lock recursively, an exception is thrown. 이 설정을 적용하는 경우 일부 클래스에서 특정 재귀가 허용될 수도 있습니다.Some classes may allow certain recursions when this setting is in effect.

SupportsRecursion 1

스레드에서 잠금을 재귀적으로 시작할 수 있습니다.A thread can enter a lock recursively. 일부 클래스에서는 이 기능이 제한될 수 있습니다.Some classes may restrict this capability.

예제

다음 예제에서는 두 가지 예외 시나리오를 보여 줍니다. 하나는 설정에 의존 하 LockRecursionPolicy 고 다른 하나는 그렇지 않습니다.The following example shows two exception scenarios, one that depends on the LockRecursionPolicy setting and one that does not.

첫 번째 시나리오에서 스레드는 읽기 모드로 잠금을 시작한 다음 재귀적으로 읽기 모드를 시작 하려고 시도 합니다.In the first scenario, the thread enters the lock in read mode and then tries to enter read mode recursively. ReaderWriterLockSlim재귀 정책을 NoRecursion로 설정 하는 매개 변수가 없는 생성자를 사용 하 여를 만든 경우 예외가 throw 됩니다.If the ReaderWriterLockSlim is created by using the parameterless constructor, which sets recursion policy to NoRecursion, an exception is thrown. SupportsRecursion를 사용 하 여를 만드는 경우에는 ReaderWriterLockSlim 예외가 throw 되지 않습니다.If SupportsRecursion is used to create the ReaderWriterLockSlim, no exception is thrown.

두 번째 시나리오에서 스레드는 읽기 모드로 잠금을 시작한 다음 쓰기 모드로 잠금을 시작 하려고 합니다.In the second scenario, the thread enters the lock in read mode and then tries to enter the lock in write mode. LockRecursionException잠금 재귀 정책에 관계 없이이 throw 됩니다.LockRecursionException is thrown regardless of the lock recursion policy.

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.
Imports System.Threading

Class Example
    ' By default, the lock recursion policy for a new 
    ' ReaderWriterLockSlim does not allow recursion.
    Private Shared rwls As New ReaderWriterLockSlim()
    Private Shared rwlsWithRecursion _
        As New ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion)
    
    Shared Sub ThreadProc() 
        
        Console.WriteLine("1. Enter the read lock recursively.")
        ReadRecursive(rwls)
        ReadRecursive(rwlsWithRecursion)
    
        Console.WriteLine(vbCrLf & _
            "2. Enter the write lock recursively from the read lock.")
        ReadWriteRecursive(rwls)
        ReadWriteRecursive(rwlsWithRecursion)

    End Sub 

    Shared Sub ReadRecursive(ByVal rwls As ReaderWriterLockSlim)

        Console.WriteLine("LockRecursionPolicy.{0}:", rwls.RecursionPolicy)
        rwls.EnterReadLock()
        
        Try
            rwls.EnterReadLock()
            Console.WriteLine(vbTab & _
                "The read lock was entered recursively.")
            rwls.ExitReadLock()
        Catch lre As LockRecursionException
            Console.WriteLine(vbTab & "{0}: {1}", _
                lre.GetType().Name, lre.Message)
        End Try

        rwls.ExitReadLock()
    End Sub

    Shared Sub ReadWriteRecursive(ByVal rwls As ReaderWriterLockSlim)

        Console.WriteLine("LockRecursionPolicy.{0}:", rwls.RecursionPolicy)
        rwls.EnterReadLock()

        Try
            rwls.EnterWriteLock()
            Console.WriteLine(vbTab & _
                "The write lock was entered recursively.")
        Catch lre As LockRecursionException
            Console.WriteLine(vbTab & "{0}: {1}", _
                lre.GetType().Name, lre.Message)
        End Try

        rwls.ExitReadLock()
    End Sub
    
    Shared Sub Main() 

        Dim t As New Thread(AddressOf ThreadProc)
        t.Start()
        t.Join()

        ' Dispose of ReaderWriterLockSlim objects' unmanaged resources.
        If rwls IsNot Nothing Then rwls.Dispose()
        If rwlsWithRecursion IsNot Nothing Then _
           rwlsWithRecursion.Dispose()
    End Sub 
End Class 

' This code example produces 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 is prone to deadlocks. Consider using the upgrade lock.
'LockRecursionPolicy.SupportsRecursion:
'        LockRecursionException: Write lock may not be acquired with read lock held. This pattern is prone to deadlocks. Consider using the upgrade lock.
' 

설명

기본 재귀 정책은 잠금 유형에 따라 달라 집니다.The default recursion policy depends on the type of lock. 지정 된 잠금 형식에 대 한 잠금 재귀의 정확한 동작 및 기본 정책은 해당 형식에 대 한 설명서를 참조 하세요.For the default policy and the precise behavior of lock recursion for any given lock type, see the documentation for the type. 예를 들어, ReaderWriterLockSlim 클래스는 잠금 정책 설정과 관계 없이 읽기 모드로 잠금을 이미 시작한 경우 스레드를 쓰기 모드로 전환 하 여 교착 상태를 줄일 수 없습니다.For example, the ReaderWriterLockSlim class does not allow a thread to enter the lock in write mode if it already entered the lock in read mode, regardless of the lock policy setting, in order to reduce the chance of deadlocks.

현재 하나의 잠금만이 열거형을 사용 합니다.Currently only one lock uses this enumeration:

적용 대상