Expand Minimize

LockRecursionPolicy Enumeration

Specifies whether a lock can be entered multiple times by the same thread.

Namespace:  System.Threading
Assembly:  System.Core (in System.Core.dll)

public enum LockRecursionPolicy

Member nameDescription
Supported by Portable Class LibrarySupported in .NET for Windows Store appsNoRecursionIf a thread tries to enter a lock recursively, an exception is thrown. Some classes may allow certain recursions when this setting is in effect.
Supported by Portable Class LibrarySupported in .NET for Windows Store appsSupportsRecursionA thread can enter a lock recursively. Some classes may restrict this capability.

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

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. If the ReaderWriterLockSlim is created by using the default constructor, which sets recursion policy to NoRecursion, an exception is thrown. 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 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();
    } 
} 
// 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.

.NET Framework

Supported in: 4.5.2, 4.5.1, 4.5, 4, 3.5

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft