5 out of 8 rated this helpful - Rate this topic

Monitor.Wait Method

.NET Framework 1.1

Other Versions

Releases the lock on an object and blocks the current thread until it reacquires the lock.

Overload List

Releases the lock on an object and blocks the current thread until it reacquires the lock.

[Visual Basic] Overloads Public Shared Function Wait(Object) As Boolean

[C#] public static bool Wait(object);

[C++] public: static bool Wait(Object*);

[JScript] public static function Wait(Object) : Boolean;

Releases the lock on an object and blocks the current thread until it reacquires the lock or a specified amount of time elapses.

[Visual Basic] Overloads Public Shared Function Wait(Object, Integer) As Boolean

[C#] public static bool Wait(object, int);

[C++] public: static bool Wait(Object*, int);

[JScript] public static function Wait(Object, int) : Boolean;

Releases the lock on an object and blocks the current thread until it reacquires the lock or a specified amount of time elapses.

[Visual Basic] Overloads Public Shared Function Wait(Object, TimeSpan) As Boolean

[C#] public static bool Wait(object, TimeSpan);

[C++] public: static bool Wait(Object*, TimeSpan);

[JScript] public static function Wait(Object, TimeSpan) : Boolean;

Waits for notification from an object that called the Pulse or PulseAll method or for a specified timer to elapse. This method also specifies whether the synchronization domain for the context (if in a synchronized context) is exited before the wait and reacquired.

[Visual Basic] Overloads Public Shared Function Wait(Object, Integer, Boolean) As Boolean

[C#] public static bool Wait(object, int, bool);

[C++] public: static bool Wait(Object*, int, bool);

[JScript] public static function Wait(Object, int, Boolean) : Boolean;

Releases the lock on an object and blocks the current thread until it reacquires the lock, or until a specified amount of time elapses, optionally exiting the synchronization domain for the synchronized context before the wait and reacquiring the domain.

[Visual Basic] Overloads Public Shared Function Wait(Object, TimeSpan, Boolean) As Boolean

[C#] public static bool Wait(object, TimeSpan, bool);

[C++] public: static bool Wait(Object*, TimeSpan, bool);

[JScript] public static function Wait(Object, TimeSpan, Boolean) : Boolean;

Example

[Visual Basic, C#, C++] The following code example demonstrates how to use the Wait method.

[Visual Basic, C#, C++] Note This example shows how to use one of the overloaded versions of Wait. For other examples that might be available, see the individual overload topics.

[Visual Basic] 
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.
               Monitor.Wait(m_smplQueue)
               'Push one element.
               m_smplQueue.Enqueue(counter)
               'Release the waiting thread.
               Monitor.Pulse(m_smplQueue)
               
               counter += 1
            End While
         End SyncLock
      End Sub 'FirstThread
      
      Public Sub SecondThread()
         SyncLock m_smplQueue
            'Release the waiting thread.
            Monitor.Pulse(m_smplQueue)
            '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.
               Console.WriteLine(counter.ToString())
               'Release the waiting thread.
               Monitor.Pulse(m_smplQueue)
            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.
         tFirst.Start()
         tSecond.Start()
         'wait to the end of the two threads
         tFirst.Join()
         tSecond.Join()
         'Print the number of queue elements.
         Console.WriteLine(("Queue Count = " + test.GetQueueCount().ToString()))
      End Sub 'Main
   End Class 'MonitorSample
End Namespace 'MonitorCS1 

[C#] 
using System;
using System.Threading;
using System.Collections;

namespace MonitorCS1
{
    class MonitorSample
    {
        const int MAX_LOOP_TIME = 1000;
        Queue    m_smplQueue;

        public MonitorSample()
        {
            m_smplQueue = new Queue(); 
        }
        public void FirstThread()
        {
            int counter = 0;
            lock(m_smplQueue)
            {
                while(counter < MAX_LOOP_TIME)
                {
                    //Wait, if the queue is busy.
                    Monitor.Wait(m_smplQueue);
                    //Push one element.
                    m_smplQueue.Enqueue(counter);
                    //Release the waiting thread.
                    Monitor.Pulse(m_smplQueue);    

                    counter++;
                }
            }
        }
        public void SecondThread()
        {
            lock(m_smplQueue)
            {
                //Release the waiting thread.
                Monitor.Pulse(m_smplQueue);
                //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.
                    int counter = (int)m_smplQueue.Dequeue();
                    //Print the first element.
                    Console.WriteLine(counter.ToString());
                    //Release the waiting thread.
                    Monitor.Pulse(m_smplQueue);
                }
            }
        }
        //Return the number of queue elements.
        public int GetQueueCount()
        {
            return m_smplQueue.Count;
        }

        static void Main(string[] args)
        {
            //Create the MonitorSample object.
            MonitorSample test = new MonitorSample();            
            //Create the first thread.
            Thread tFirst = new Thread(new ThreadStart(test.FirstThread));
            //Create the second thread.
            Thread tSecond = new Thread(new ThreadStart(test.SecondThread));
            //Start threads.
            tFirst.Start();
            tSecond.Start();
            //wait to the end of the two threads
            tFirst.Join();
            tSecond.Join();            
            //Print the number of queue elements.
            Console.WriteLine("Queue Count = " + test.GetQueueCount().ToString());
        }
    }
}

[C++] 
#using <mscorlib.dll>

using namespace System;
using namespace System::Threading;
using namespace System::Collections;

__gc class MonitorSample
{
public:
    MonitorSample();
    void FirstThread();
    void SecondThread();
    int GetQueueCount();

private:
    static const int MAX_LOOP_TIME = 1000;
    Queue*    m_smplQueue;
};

MonitorSample::MonitorSample()
{
    m_smplQueue = new Queue(); 
}

void MonitorSample::FirstThread()
{
    int counter = 0;
    Monitor::Enter(m_smplQueue);
    while(counter < MAX_LOOP_TIME)
    {
        //Wait, if the queue is busy.
        Monitor::Wait(m_smplQueue);
        //Push one element.
        m_smplQueue->Enqueue(__box(counter));
        //Release the waiting thread.
        Monitor::Pulse(m_smplQueue);   

        counter++;
    }
    Monitor::Exit(m_smplQueue);
}

void MonitorSample::SecondThread()
{
    Monitor::Enter(m_smplQueue);
    //Release the waiting thread.
    Monitor::Pulse(m_smplQueue);
    //Wait in the loop, while the queue is busy.
    //Exit on the time-out when the first thread stopped. 
    while(Monitor::Wait(m_smplQueue,1000))
    {
        //Pop the first element.
        int counter = *dynamic_cast<__box int*>(m_smplQueue->Dequeue());
        //Print the first element.
        Console::WriteLine(counter.ToString());
        //Release the waiting thread.
        Monitor::Pulse(m_smplQueue);
    }
    Monitor::Exit(m_smplQueue);
}

//Return the number of queue elements.
int MonitorSample::GetQueueCount()
{
    return m_smplQueue->Count;
}

int main()
{
    //Create the MonitorSample object.
    MonitorSample* test = new MonitorSample();         
    //Create the first thread.
    Thread* tFirst = new Thread(new ThreadStart(test, &MonitorSample::FirstThread));
    //Create the second thread.
    Thread* tSecond = new Thread(new ThreadStart(test, &MonitorSample::SecondThread));
    //Start threads.
    tFirst->Start();
    tSecond->Start();
    //wait to the end of the two threads
    tFirst->Join();
    tSecond->Join();         
    //Print the number of queue elements.
    Console::WriteLine(String::Concat(S"Queue Count = ", test->GetQueueCount().ToString()));
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button in the upper-left corner of the page.

Monitor.Wait Method

Overload List

Example

See Also