This documentation is archived and is not being maintained.

Monitor.Wait Method (Object, Int32, Boolean)

Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. This method also specifies whether the synchronization domain for the context (if in a synchronized context) is exited before the wait and reacquired afterward.

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

Public Shared Function Wait ( _
	obj As Object, _
	millisecondsTimeout As Integer, _
	exitContext As Boolean _
) As Boolean
Dim obj As Object
Dim millisecondsTimeout As Integer
Dim exitContext As Boolean
Dim returnValue As Boolean

returnValue = Monitor.Wait(obj, millisecondsTimeout, exitContext)
public static boolean Wait (
	Object obj, 
	int millisecondsTimeout, 
	boolean exitContext
public static function Wait (
	obj : Object, 
	millisecondsTimeout : int, 
	exitContext : boolean
) : boolean



The object on which to wait.


The number of milliseconds to wait before the thread enters the ready queue.


true to exit and reacquire the synchronization domain for the context (if in a synchronized context) before the wait; otherwise, false.

Return Value

true if the lock was reacquired before the specified time elapsed; otherwise, false.

Exception typeCondition


The obj parameter is a null reference (Nothing in Visual Basic).


Wait is not invoked from within a synchronized block of code.


The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's Interrupt method.


The value of the millisecondsTimeout parameter is negative, and is not equal to Infinite.

This method does not return until it reacquires an exclusive lock on the obj parameter.

The thread that currently owns the lock on the specified object invokes this method in order to release the object so that another thread can access it. The caller is blocked while waiting to reacquire the lock. This method is called when the caller needs to wait for a state change that will occur as a result of another thread's operations.

The time-out ensures that the current thread does not block indefinitely if another thread releases the lock without first calling the Pulse or PulseAll method. It also moves the thread to the ready queue, bypassing other threads ahead of it in the wait queue, so that it can reacquire the lock sooner. The thread can test the return value of the Wait method to determine whether it reacquired the lock prior to the time-out. The thread can evaluate the conditions that caused it to enter the wait, and if necessary call the Wait method again.

When a thread calls Wait, it releases the lock and enters the waiting queue. At this point, the next thread in the ready queue (if there is one) is allowed to take control of the lock. The thread that invoked Wait remains in the waiting queue until either a thread that holds the lock invokes PulseAll, or it is the next in the queue and a thread that holds the lock invokes Pulse. However, if millisecondsTimeout elapses before another thread invokes this object's Pulse or PulseAll method, the original thread is moved to the ready queue in order to regain the lock.


If Infinite is specified for the millisecondsTimeout parameter, this method blocks indefinitely unless the holder of the lock calls Pulse or PulseAll. If millisecondsTimeout equals 0, the thread that calls Wait releases the lock and then immediately enters the ready queue in order to regain the lock.

The caller executes Wait once, regardless of the number of times Enter has been invoked for the specified object. Conceptually, the Wait method stores the number of times the caller invoked Enter on the object and invokes Exit as many times as necessary to fully release the locked object. The caller then blocks while waiting to reacquire the object. When the caller reacquires the lock, the system calls Enter as many times as necessary to restore the saved Enter count for the caller. Calling Wait releases the lock for the specified object only; if the caller is the owner of locks on other objects, these locks are not released.


A synchronized object holds several references, including a reference to the thread that currently holds the lock, a reference to the ready queue, which contains the threads that are ready to obtain the lock, and a reference to the waiting queue, which contains the threads that are waiting for notification of a change in the object's state.

The Pulse, PulseAll, and Wait methods must be invoked from within a synchronized block of code.

The remarks for the Pulse method explain what happens if Pulse is called when no threads are waiting.

Notes on Exiting the Context

The exitContext parameter has no effect unless the Wait method is called from inside a nondefault managed context. This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Even if you are currently executing a method on a class that is not derived from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the Wait method. It returns to the original nondefault context after the call to the Wait method completes.

This can be useful when the context-bound class has the SynchronizationAttribute attribute applied. In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. If code in the call stack of a member calls the Wait method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. When the Wait method returns, the thread that made the call must wait to reenter the synchronization domain.

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

Imports System
Imports System.Threading
Imports System.Collections

Namespace MonitorCS1
   Class MonitorSample
      Private MAX_LOOP_TIME As Integer = 1000
      Private m_smplQueue As Queue
      Public Sub New()
         m_smplQueue = New Queue()
      End Sub 'New
      Public Sub FirstThread()
         Dim counter As Integer = 0
         SyncLock m_smplQueue
            While counter < MAX_LOOP_TIME
               'Wait, if the queue is busy.
               'Push one element.
               'Release the waiting thread.
               counter += 1
            End While
         End SyncLock
      End Sub 'FirstThread
      Public Sub SecondThread()
         SyncLock m_smplQueue
            'Release the waiting thread.
            'Wait in the loop while the queue is busy.
            'Exit on the time-out when the first thread stops. 
            While Monitor.Wait(m_smplQueue, 1000)
               'Pop the first element.
               Dim counter As Integer = CInt(m_smplQueue.Dequeue())
               'Print the first element.
               'Release the waiting thread.
            End While
         End SyncLock
      End Sub 'SecondThread
      'Return the number of queue elements.
      Public Function GetQueueCount() As Integer
         Return m_smplQueue.Count
      End Function 'GetQueueCount
      Public Shared Sub Main(args() As String)
         'Create the MonitorSample object.
         Dim test As New MonitorSample()
         'Create the first thread.
         Dim tFirst As New Thread(AddressOf test.FirstThread)
         'Create the second thread.
         Dim tSecond As New Thread(AddressOf test.SecondThread)
         'Start threads.
         'wait to the end of the two threads
         'Print the number of queue elements.
         Console.WriteLine(("Queue Count = " + test.GetQueueCount().ToString()))
      End Sub 'Main
   End Class 'MonitorSample
End Namespace 'MonitorCS1 

package MonitorJSL1;

import System.*;
import System.Threading.*;
import System.Collections.*;

class MonitorSample
    private int MAX_LOOP_TIME = 1000;
    private Queue mSmplQueue;

    public MonitorSample()
        mSmplQueue = new Queue();
    } //MonitorSample

    public void FirstThread()
        int counter = 0;
        synchronized (mSmplQueue) {
            while (counter < MAX_LOOP_TIME) {
                //Wait, if the queue is busy.

                //Push one element.

                //Release the waiting thread.
    } //FirstThread

    public void SecondThread()
        synchronized (mSmplQueue) {
            //Release the waiting thread.

            //Wait in the loop, while the queue is busy.
            //Exit on the time-out when the first thread stops. 
            while (Monitor.Wait(mSmplQueue, 1000)) {
                //Pop the first element.
                int counter = Convert.ToInt32(mSmplQueue.Dequeue());

                //Print the first element.

                //Release the waiting thread.
    } //SecondThread

    //Return the number of queue elements.
    public int GetQueueCount()
        return mSmplQueue.get_Count();
    } //GetQueueCount

    public static void main(String[] args)
        //Create the MonitorSample object.
        MonitorSample test = new MonitorSample();

        //Create the first thread.
        System.Threading.Thread tFirst = 
            new System.Threading.Thread(new ThreadStart(test.FirstThread));

        //Create the second thread.
        System.Threading.Thread tSecond = 
            new System.Threading.Thread(new ThreadStart(test.SecondThread));

        //Start threads.

        //wait to the end of the two threads

        //Print the number of queue elements.
        Console.WriteLine("Queue Count = "
            + Convert.ToString(test.GetQueueCount()));
    } //main
} //MonitorSample

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

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

.NET Framework

Supported in: 2.0, 1.1, 1.0