Udostępnij za pośrednictwem

LockRecursionPolicy Wyliczenie

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Threading
Zestaw:
System.Threading.dll
Zestaw:
System.Core.dll
Zestaw:
netstandard.dll

Określa, czy blokada może być wprowadzana wiele razy przez ten sam wątek.

public enum class LockRecursionPolicy
public enum LockRecursionPolicy
type LockRecursionPolicy = 
Public Enum LockRecursionPolicy
Dziedziczenie
Object
ValueType
Enum
LockRecursionPolicy

Pola

NoRecursion 0

Jeśli wątek próbuje wprowadzić blokadę cyklicznie, zgłaszany jest wyjątek. Niektóre klasy mogą zezwalać na pewne rekursje, gdy to ustawienie jest w życie.
SupportsRecursion 1

Wątek może cyklicznie wprowadzać blokadę. Niektóre klasy mogą ograniczać tę funkcję.

Przykłady

W poniższym przykładzie przedstawiono dwa scenariusze wyjątków, jeden, który zależy od LockRecursionPolicy ustawienia i jeden, który nie.

W pierwszym scenariuszu wątek wprowadza blokadę w trybie odczytu, a następnie próbuje cyklicznie wprowadzić tryb odczytu. Jeśli obiekt ReaderWriterLockSlim jest tworzony przy użyciu konstruktora bez parametrów, który ustawia zasady rekursji na Wartość NoRecursion, zgłaszany jest wyjątek. Jeśli funkcja SupportsRecursion jest używana do utworzenia elementu ReaderWriterLockSlim, nie jest zgłaszany wyjątek.

W drugim scenariuszu wątek wprowadza blokadę w trybie odczytu, a następnie próbuje wprowadzić blokadę w trybie zapisu. LockRecursionException jest zgłaszany niezależnie od zasad rekursji blokady.

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.
'

Uwagi

Domyślne zasady rekursji zależą od typu blokady. Aby zapoznać się z zasadami domyślnymi i dokładnym zachowaniem rekursji blokady dla dowolnego typu blokady, zobacz dokumentację typu. Na przykład ReaderWriterLockSlim klasa nie zezwala wątkowi na wprowadzanie blokady w trybie zapisu, jeśli została już wprowadzona blokada w trybie odczytu, niezależnie od ustawienia zasad blokady, aby zmniejszyć prawdopodobieństwo zakleszczenia.

Obecnie tylko jedna blokada używa tej wyliczenia:

Dotyczy