Monitor.TryEnter Method

Source:

Monitor.cs

Source:

Monitor.cs

Source:

Monitor.cs

Source:

Monitor.cs

Source:

Monitor.cs

public:
 static void TryEnter(System::Object ^ obj, TimeSpan timeout, bool % lockTaken);

public static void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken);

static member TryEnter : obj * TimeSpan * bool -> unit

Public Shared Sub TryEnter (obj As Object, timeout As TimeSpan, ByRef lockTaken As Boolean)

Parameters

Exceptions

Remarks

If the value of the timeout parameter converted to milliseconds equals -1, this method is equivalent to Enter(Object). If the value of timeout equals 0, this method is equivalent to TryEnter(Object).

If the lock was not taken because an exception was thrown, the variable specified for the lockTaken parameter is false after this method ends. This allows the program to determine, in all cases, whether it is necessary to release the lock.

To ensure that the thread does not enter the critical section, you should examine the value of lockTaken and execute code in the critical section only if its value is true. The following code fragment shows the pattern used to call this method. Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
var timeout = TimeSpan.FromMilliseconds(500);
bool lockTaken = false;

try {
 Monitor.TryEnter(lockObj, timeout, ref lockTaken);
 if (lockTaken) {
 // The critical section.
 }
 else {
 // The lock was not acquired.
 }
}
finally {
 // Ensure that the lock is released.
 if (lockTaken) {
 Monitor.Exit(lockObj);
 }
}

Dim lockObj As New Object()
Dim timeout = TimeSpan.FromMilliseconds(500)
Dim lockTaken As Boolean = False

Try
 Monitor.TryEnter(lockObj, timeout, lockTaken)
 If lockTaken Then
 ' The critical section.
 Else
 ' The lock was not acquired.
 End If
Finally
 ' Ensure that the lock is released.
 If lockTaken Then Monitor.Exit(lockObj)
End Try

See also

• Thread
• Managed Threading

Source:

Monitor.CoreCLR.cs

Source:

Monitor.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

public:
 static void TryEnter(System::Object ^ obj, int millisecondsTimeout, bool % lockTaken);

public static void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken);

static member TryEnter : obj * int * bool -> unit

Public Shared Sub TryEnter (obj As Object, millisecondsTimeout As Integer, ByRef lockTaken As Boolean)

Parameters

Exceptions

Examples

The following code shows the basic pattern for using the TryEnter(Object, Boolean) method overload. This overload always sets the value of the variable that is passed to the ref parameter (ByRef in Visual Basic) lockTaken, even if the method throws an exception, so the value of the variable is a reliable way to test whether the lock has to be released.

bool acquiredLock = false;

try
{
 Monitor.TryEnter(lockObject, 500, ref acquiredLock);
 if (acquiredLock)
 {

 // Code that accesses resources that are protected by the lock.
 }
 else
 {
 
 // Code to deal with the fact that the lock was not acquired.
 }
}
finally
{
 if (acquiredLock)
 {
 Monitor.Exit(lockObject);
 }
}

Dim acquiredLock As Boolean = False

Try
 Monitor.TryEnter(lockObject, 500, acquiredLock)
 If acquiredLock Then

 ' Code that accesses resources that are protected by the lock.

 Else

 ' Code to deal with the fact that the lock was not acquired.

 End If
Finally
 If acquiredLock Then
 Monitor.Exit(lockObject)
 End If
End Try

Remarks

If the millisecondsTimeout parameter equals Infinite, this method is equivalent to Enter(Object). If millisecondsTimeout equals 0, this method is equivalent to TryEnter(Object).

If the lock was not taken because an exception was thrown, the variable specified for the lockTaken parameter is false after this method ends. This allows the program to determine, in all cases, whether it is necessary to release the lock.

To ensure that the thread does not enter the critical section, you should examine the value of lockTaken and execute code in the critical section only if its value is true. The following code fragment shows the pattern used to call this method. Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
int timeout = 500;
bool lockTaken = false;

try {
 Monitor.TryEnter(lockObj, timeout, ref lockTaken);
 if (lockTaken) {
 // The critical section.
 }
 else {
 // The lock was not acquired.
 }
}
finally {
 // Ensure that the lock is released.
 if (lockTaken) {
 Monitor.Exit(lockObj);
 } 
}

Dim lockObj As New Object()
Dim timeout As Integer = 500
Dim lockTaken As Boolean = False

Try
 Monitor.TryEnter(lockObj, timeout, lockTaken)
 If lockTaken Then
 ' The critical section.
 Else
 ' The lock was not acquired.
 End If
Finally
 ' Ensure that the lock is released.
 If lockTaken Then Monitor.Exit(lockObj)
End Try

Source:

Monitor.cs

Source:

Monitor.cs

Source:

Monitor.cs

Source:

Monitor.cs

Source:

Monitor.cs

public:
 static bool TryEnter(System::Object ^ obj, TimeSpan timeout);

public static bool TryEnter(object obj, TimeSpan timeout);

static member TryEnter : obj * TimeSpan -> bool

Public Shared Function TryEnter (obj As Object, timeout As TimeSpan) As Boolean

Parameters

Returns

true if the current thread acquires the lock; otherwise, false.

Exceptions

Remarks

If the value of the timeout parameter converted to milliseconds equals -1, this method is equivalent to Enter. If the value of timeout equals 0, this method is equivalent to TryEnter.

To ensure that the thread does not enter the critical section, you should examine the method's return value and execute code in the critical section only if its return value is true. The following code fragment shows the pattern used to call this method. Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
var timeout = TimeSpan.FromMilliseconds(500);

if (Monitor.TryEnter(lockObj, timeout)) {
 try {
 // The critical section.
 }
 finally {
 // Ensure that the lock is released.
 Monitor.Exit(lockObj);
 }
}
else {
 // The lock was not acquired.
}

Dim lockObj As New Object()
Dim timeout = TimeSpan.FromMilliseconds(500)

If Monitor.TryEnter(lockObj, timeout) Then
 Try
 ' The critical section.
 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(lockObj)
 End Try
Else
 ' The lock was not acquired.
End If

See also

• Thread
• Managed Threading

Source:

Monitor.CoreCLR.cs

Source:

Monitor.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

public:
 static void TryEnter(System::Object ^ obj, bool % lockTaken);

public static void TryEnter(object obj, ref bool lockTaken);

static member TryEnter : obj * bool -> unit

Public Shared Sub TryEnter (obj As Object, ByRef lockTaken As Boolean)

Parameters

Exceptions

Examples

The following code shows the basic pattern for using the TryEnter(Object, Boolean) method overload. This overload always sets the value of the variable that is passed to the ref parameter (ByRef in Visual Basic) lockTaken, even if the method throws an exception, so the value of the variable is a reliable way to test whether the lock has to be released.

bool acquiredLock = false;

try
{
 Monitor.TryEnter(lockObject, ref acquiredLock);
 if (acquiredLock)
 {

 // Code that accesses resources that are protected by the lock.
 }
 else
 {
 
 // Code to deal with the fact that the lock was not acquired.
 }
}
finally
{
 if (acquiredLock)
 {
 Monitor.Exit(lockObject);
 }
}

Dim acquiredLock As Boolean = False

Try
 Monitor.TryEnter(lockObject, acquiredLock)
 If acquiredLock Then

 ' Code that accesses resources that are protected by the lock.

 Else

 ' Code to deal with the fact that the lock was not acquired.

 End If
Finally
 If acquiredLock Then
 Monitor.Exit(lockObject)
 End If
End Try

Remarks

If successful, this method acquires an exclusive lock on the obj parameter. This method returns immediately, whether or not the lock is available.

If the lock was not taken because an exception was thrown, the variable specified for the lockTaken parameter is false after this method ends. This allows the program to determine, in all cases, whether it is necessary to release the lock.

This method is similar to Enter(Object, Boolean), but it will never block the current thread. If the thread cannot enter without blocking, the lockTaken argument is set to false when the method returns.

To ensure that the thread does not enter the critical section, you should examine the value of lockTaken and execute code in the critical section only if its value is true. The following code fragment shows the pattern used to call this method. Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
bool lockTaken = false;

try {
 Monitor.TryEnter(lockObj, ref lockTaken); 
 if (lockTaken) {
 // The critical section.
 }
 else {
 // The lock was not acquired.
 }
}
finally {
 // Ensure that the lock is released.
 if (lockTaken) {
 Monitor.Exit(lockObj);
 }
}

Dim lockObj As New Object()
Dim lockTaken As Boolean = False

Try 
 Monitor.TryEnter(lockObj, lockTaken) 
 If lockTaken Then
 ' The critical section.
 Else 
 ' The lock was not acquired.
 End If
Finally 
 ' Ensure that the lock is released.
 If lockTaken Then Monitor.Exit(lockObj)
End Try

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

public:
 static bool TryEnter(System::Object ^ obj);

public static bool TryEnter(object obj);

static member TryEnter : obj -> bool

Public Shared Function TryEnter (obj As Object) As Boolean

Parameters

Returns

true if the current thread acquires the lock; otherwise, false.

Exceptions

Examples

The following code example demonstrates how to use the TryEnter method.

using System;
using System.Threading;
using System.Collections.Generic;
using System.Text;

class SafeQueue<T>
{
 // A queue that is protected by Monitor.
 private Queue<T> m_inputQueue = new Queue<T>();

 // Lock the queue and add an element.
 public void Enqueue(T qValue)
 {
 // Request the lock, and block until it is obtained.
 Monitor.Enter(m_inputQueue);
 try
 {
 // When the lock is obtained, add an element.
 m_inputQueue.Enqueue(qValue);
 }
 finally
 {
 // Ensure that the lock is released.
 Monitor.Exit(m_inputQueue);
 }
 }

 // Try to add an element to the queue: Add the element to the queue
 // only if the lock is immediately available.
 public bool TryEnqueue(T qValue)
 {
 // Request the lock.
 if (Monitor.TryEnter(m_inputQueue))
 {
 try
 {
 m_inputQueue.Enqueue(qValue);
 }
 finally
 {
 // Ensure that the lock is released.
 Monitor.Exit(m_inputQueue);
 }
 return true;
 }
 else
 {
 return false;
 }
 }

 // Try to add an element to the queue: Add the element to the queue
 // only if the lock becomes available during the specified time
 // interval.
 public bool TryEnqueue(T qValue, int waitTime)
 {
 // Request the lock.
 if (Monitor.TryEnter(m_inputQueue, waitTime))
 {
 try
 {
 m_inputQueue.Enqueue(qValue);
 }
 finally
 {
 // Ensure that the lock is released.
 Monitor.Exit(m_inputQueue);
 }
 return true;
 }
 else
 {
 return false;
 }
 }

 // Lock the queue and dequeue an element.
 public T Dequeue()
 {
 T retval;

 // Request the lock, and block until it is obtained.
 Monitor.Enter(m_inputQueue);
 try
 {
 // When the lock is obtained, dequeue an element.
 retval = m_inputQueue.Dequeue();
 }
 finally
 {
 // Ensure that the lock is released.
 Monitor.Exit(m_inputQueue);
 }

 return retval;
 }

 // Delete all elements that equal the given object.
 public int Remove(T qValue)
 {
 int removedCt = 0;

 // Wait until the lock is available and lock the queue.
 Monitor.Enter(m_inputQueue);
 try
 {
 int counter = m_inputQueue.Count;
 while (counter > 0)
 // Check each element.
 {
 T elem = m_inputQueue.Dequeue();
 if (!elem.Equals(qValue))
 {
 m_inputQueue.Enqueue(elem);
 }
 else
 {
 // Keep a count of items removed.
 removedCt += 1;
 }
 counter = counter - 1;
 }
 }
 finally
 {
 // Ensure that the lock is released.
 Monitor.Exit(m_inputQueue);
 }

 return removedCt;
 }

 // Print all queue elements.
 public string PrintAllElements()
 {
 StringBuilder output = new StringBuilder();

 // Lock the queue.
 Monitor.Enter(m_inputQueue);
 try
 {
 foreach( T elem in m_inputQueue )
 {
 // Print the next element.
 output.AppendLine(elem.ToString());
 }
 }
 finally
 {
 // Ensure that the lock is released.
 Monitor.Exit(m_inputQueue);
 }

 return output.ToString();
 }
}

public class Example
{
 private static SafeQueue<int> q = new SafeQueue<int>();
 private static int threadsRunning = 0;
 private static int[][] results = new int[3][];

 static void Main()
 {
 Console.WriteLine("Working...");

 for(int i = 0; i < 3; i++)
 {
 Thread t = new Thread(ThreadProc);
 t.Start(i);
 Interlocked.Increment(ref threadsRunning);
 }
 }

 private static void ThreadProc(object state)
 {
 DateTime finish = DateTime.Now.AddSeconds(10);
 Random rand = new Random();
 int[] result = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 int threadNum = (int) state;

 while (DateTime.Now < finish)

 {
 int what = rand.Next(250);
 int how = rand.Next(100);

 if (how < 16)
 {
 q.Enqueue(what);
 result[(int)ThreadResultIndex.EnqueueCt] += 1;
 }
 else if (how < 32)
 {
 if (q.TryEnqueue(what))
 {
 result[(int)ThreadResultIndex.TryEnqueueSucceedCt] += 1;
 }
 else
 {
 result[(int)ThreadResultIndex.TryEnqueueFailCt] += 1;
 }
 }
 else if (how < 48)
 {
 // Even a very small wait significantly increases the success
 // rate of the conditional enqueue operation.
 if (q.TryEnqueue(what, 10))
 {
 result[(int)ThreadResultIndex.TryEnqueueWaitSucceedCt] += 1;
 }
 else
 {
 result[(int)ThreadResultIndex.TryEnqueueWaitFailCt] += 1;
 }
 }
 else if (how < 96)
 {
 result[(int)ThreadResultIndex.DequeueCt] += 1;
 try
 {
 q.Dequeue();
 }
 catch
 {
 result[(int)ThreadResultIndex.DequeueExCt] += 1;
 }
 }
 else
 {
 result[(int)ThreadResultIndex.RemoveCt] += 1;
 result[(int)ThreadResultIndex.RemovedCt] += q.Remove(what);
 }
 }

 results[threadNum] = result;

 if (0 == Interlocked.Decrement(ref threadsRunning))
 {
 StringBuilder sb = new StringBuilder(
 " Thread 1 Thread 2 Thread 3 Total\n");

 for(int row = 0; row < 9; row++)
 {
 int total = 0;
 sb.Append(titles[row]);

 for(int col = 0; col < 3; col++)
 {
 sb.Append(String.Format("{0,9}", results[col][row]));
 total += results[col][row];
 }

 sb.AppendLine(String.Format("{0,9}", total));
 }

 Console.WriteLine(sb.ToString());
 }
 }

 private static string[] titles = {
 "Enqueue ",
 "TryEnqueue succeeded ",
 "TryEnqueue failed ",
 "TryEnqueue(T, wait) succeeded ",
 "TryEnqueue(T, wait) failed ",
 "Dequeue attempts ",
 "Dequeue exceptions ",
 "Remove operations ",
 "Queue elements removed "};

 private enum ThreadResultIndex
 {
 EnqueueCt,
 TryEnqueueSucceedCt,
 TryEnqueueFailCt,
 TryEnqueueWaitSucceedCt,
 TryEnqueueWaitFailCt,
 DequeueCt,
 DequeueExCt,
 RemoveCt,
 RemovedCt
 };
}

/* This example produces output similar to the following:

Working...
 Thread 1 Thread 2 Thread 3 Total
Enqueue 277382 515209 308464 1101055
TryEnqueue succeeded 276873 514621 308099 1099593
TryEnqueue failed 109 181 134 424
TryEnqueue(T, wait) succeeded 276913 514434 307607 1098954
TryEnqueue(T, wait) failed 2 0 0 2
Dequeue attempts 830980 1544081 924164 3299225
Dequeue exceptions 12102 21589 13539 47230
Remove operations 69550 129479 77351 276380
Queue elements removed 11957 22572 13043 47572
 */

Imports System.Threading
Imports System.Collections.Generic
Imports System.Text

Class SafeQueue(Of T)

 ' A queue that is protected by Monitor.
 Private m_inputQueue As New Queue(Of T)

 ' Lock the queue and add an element.
 Public Sub Enqueue(ByVal qValue As T)

 ' Request the lock, and block until it is obtained.
 Monitor.Enter(m_inputQueue)
 Try
 ' When the lock is obtained, add an element.
 m_inputQueue.Enqueue(qValue)

 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(m_inputQueue)
 End Try
 End Sub

 ' Try to add an element to the queue: Add the element to the queue 
 ' only if the lock is immediately available.
 Public Function TryEnqueue(ByVal qValue As T) As Boolean

 ' Request the lock.
 If Monitor.TryEnter(m_inputQueue) Then
 Try
 m_inputQueue.Enqueue(qValue)

 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(m_inputQueue)
 End Try
 Return True
 Else
 Return False
 End If
 End Function

 ' Try to add an element to the queue: Add the element to the queue 
 ' only if the lock becomes available during the specified time
 ' interval.
 Public Function TryEnqueue(ByVal qValue As T, ByVal waitTime As Integer) As Boolean

 ' Request the lock.
 If Monitor.TryEnter(m_inputQueue, waitTime) Then
 Try
 m_inputQueue.Enqueue(qValue)

 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(m_inputQueue)
 End Try
 Return True
 Else
 Return False
 End If
 End Function

 ' Lock the queue and dequeue an element.
 Public Function Dequeue() As T

 Dim retval As T

 ' Request the lock, and block until it is obtained.
 Monitor.Enter(m_inputQueue)
 Try
 ' When the lock is obtained, dequeue an element.
 retval = m_inputQueue.Dequeue()

 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(m_inputQueue)
 End Try

 Return retval
 End Function

 ' Delete all elements that equal the given object.
 Public Function Remove(ByVal qValue As T) As Integer

 Dim removedCt As Integer = 0

 ' Wait until the lock is available and lock the queue.
 Monitor.Enter(m_inputQueue)
 Try
 Dim counter As Integer = m_inputQueue.Count
 While (counter > 0)
 'Check each element.
 Dim elem As T = m_inputQueue.Dequeue()
 If Not elem.Equals(qValue) Then
 m_inputQueue.Enqueue(elem)
 Else
 ' Keep a count of items removed.
 removedCt += 1
 End If
 counter = counter - 1
 End While

 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(m_inputQueue)
 End Try

 Return removedCt
 End Function

 ' Print all queue elements.
 Public Function PrintAllElements() As String

 Dim output As New StringBuilder()

 'Lock the queue.
 Monitor.Enter(m_inputQueue)
 Try
 For Each elem As T In m_inputQueue
 ' Print the next element.
 output.AppendLine(elem.ToString())
 Next

 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(m_inputQueue)
 End Try

 Return output.ToString()
 End Function
End Class

Public Class Example

 Private Shared q As New SafeQueue(Of Integer)
 Private Shared threadsRunning As Integer = 0
 Private Shared results(2)() As Integer

 Friend Shared Sub Main()

 Console.WriteLine("Working...")

 For i As Integer = 0 To 2

 Dim t As New Thread(AddressOf ThreadProc)
 t.Start(i)
 Interlocked.Increment(threadsRunning)

 Next i

 End Sub

 Private Shared Sub ThreadProc(ByVal state As Object)

 Dim finish As DateTime = DateTime.Now.AddSeconds(10)
 Dim rand As New Random()
 Dim result() As Integer = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 Dim threadNum As Integer = CInt(state)

 While (DateTime.Now < finish)

 Dim what As Integer = rand.Next(250)
 Dim how As Integer = rand.Next(100)

 If how < 16 Then
 q.Enqueue(what)
 result(ThreadResultIndex.EnqueueCt) += 1
 Else If how < 32 Then
 If q.TryEnqueue(what)
 result(ThreadResultIndex.TryEnqueueSucceedCt) += 1
 Else
 result(ThreadResultIndex.TryEnqueueFailCt) += 1
 End If
 Else If how < 48 Then
 ' Even a very small wait significantly increases the success 
 ' rate of the conditional enqueue operation.
 If q.TryEnqueue(what, 10)
 result(ThreadResultIndex.TryEnqueueWaitSucceedCt) += 1
 Else
 result(ThreadResultIndex.TryEnqueueWaitFailCt) += 1
 End If
 Else If how < 96 Then
 result(ThreadResultIndex.DequeueCt) += 1
 Try
 q.Dequeue()
 Catch
 result(ThreadResultIndex.DequeueExCt) += 1
 End Try
 Else
 result(ThreadResultIndex.RemoveCt) += 1
 result(ThreadResultIndex.RemovedCt) += q.Remove(what)
 End If
 
 End While

 results(threadNum) = result

 If 0 = Interlocked.Decrement(threadsRunning) Then
 
 Dim sb As New StringBuilder( _
 " Thread 1 Thread 2 Thread 3 Total" & vbLf)

 For row As Integer = 0 To 8

 Dim total As Integer = 0
 sb.Append(titles(row))

 For col As Integer = 0 To 2

 sb.Append(String.Format("{0,9}", results(col)(row)))
 total += results(col)(row)

 Next col

 sb.AppendLine(String.Format("{0,9}", total))

 Next row

 Console.WriteLine(sb.ToString())

 End If 
 
 End Sub

 Private Shared titles() As String = { _
 "Enqueue ", _
 "TryEnqueue succeeded ", _
 "TryEnqueue failed ", _
 "TryEnqueue(T, wait) succeeded ", _
 "TryEnqueue(T, wait) failed ", _
 "Dequeue attempts ", _
 "Dequeue exceptions ", _
 "Remove operations ", _
 "Queue elements removed " _
 }

 Private Enum ThreadResultIndex
 EnqueueCt
 TryEnqueueSucceedCt
 TryEnqueueFailCt
 TryEnqueueWaitSucceedCt
 TryEnqueueWaitFailCt
 DequeueCt
 DequeueExCt
 RemoveCt
 RemovedCt
 End Enum

End Class

' This example produces output similar to the following:
'
'Working...
' Thread 1 Thread 2 Thread 3 Total
'Enqueue 294357 512164 302838 1109359
'TryEnqueue succeeded 294486 512403 303117 1110006
'TryEnqueue failed 108 234 127 469
'TryEnqueue(T, wait) succeeded 294259 512796 302556 1109611
'TryEnqueue(T, wait) failed 1 1 1 3
'Dequeue attempts 882266 1537993 907795 3328054
'Dequeue exceptions 12691 21474 13480 47645
'Remove operations 74059 128715 76187 278961
'Queue elements removed 12667 22606 13219 48492

Remarks

If successful, this method acquires an exclusive lock on the obj parameter. This method returns immediately, whether or not the lock is available.

This method is similar to Enter, but it will never block the current thread. If the thread cannot enter without blocking, the method returns false,.

To ensure that the thread does not enter the critical section, you should examine the method's return value and execute code in the critical section only if its return value is true. The following code fragment shows the pattern used to call this method. Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();

if (Monitor.TryEnter(lockObj)) {
 try {
 // The critical section.
 }
 finally {
 // Ensure that the lock is released.
 Monitor.Exit(lockObj);
 }
}
else {
 // The lock was not axquired.
}

Dim lockObj As New Object()

If Monitor.TryEnter(lockObj) Then
 Try
 ' The critical section.
 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(lockObj)
 End Try
Else
 ' The lock was not acquired.
End If

See also

• Thread
• Managed Threading

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

Source:

Monitor.CoreCLR.cs

public:
 static bool TryEnter(System::Object ^ obj, int millisecondsTimeout);

public static bool TryEnter(object obj, int millisecondsTimeout);

static member TryEnter : obj * int -> bool

Public Shared Function TryEnter (obj As Object, millisecondsTimeout As Integer) As Boolean

Parameters

Returns

true if the current thread acquires the lock; otherwise, false.

Exceptions

Remarks

If the millisecondsTimeout parameter equals Infinite, this method is equivalent to Enter. If millisecondsTimeout equals 0, this method is equivalent to TryEnter.

To ensure that the thread does not enter the critical section, you should examine the method's return value and execute code in the critical section only if its return value is true. The following code fragment shows the pattern used to call this method. Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
int timeout = 500;

if (Monitor.TryEnter(lockObj, timeout)) {
 try {
 // The critical section.
 }
 finally {
 // Ensure that the lock is released.
 Monitor.Exit(lockObj);
 }
}
else {
 // The lock was not acquired.
}

Dim lockObj As New Object()
Dim timeout As Integer = 500

If Monitor.TryEnter(lockObj, timeout) Then
 Try
 ' The critical section.
 Finally
 ' Ensure that the lock is released.
 Monitor.Exit(lockObj)
 End Try
Else
 ' The lock was not acquired.
End If

See also

• Thread
• Managed Threading