Monitor And Lock In C#

Wait releases the lock if it is held and waits to be notified. When Wait is notified, it returns and obtains the lock again. Both a Pulse and PulseAll signal for the next thread in the wait queue to proceed.

The following is the syntax for using a monitor.

try  
{  
    int x = 1;  
      
   Monitor.Enter(x);  
    try  
    {  
        // Code that needs to be protected by the monitor.  
    }  
    finally  
    {  
          
       Monitor.Exit(x);  
    }  
}  
catch (SynchronizationLockException SyncEx)  
{  
    Console.WriteLine("A SynchronizationLockException occurred. Message:");  
    Console.WriteLine(SyncEx.Message);  
}

Sample Code

namespace Monitor_Lock  
{  
    class Program  
    {  
        static readonly object _object = new object();  
  
        public static void PrintNumbers()  
        {  
            Monitor.Enter(_object);  
            try  
            {  
                for (int i = 0; i < 5; i++)  
                {  
                    Thread.Sleep(100);  
                    Console.Write(i + ",");  
                }  
                Console.WriteLine();  
            }  
            finally  
            {  
                Monitor.Exit(_object);  
            }  
        }  
  
        static void TestLock()  
        {  
              
            lock (_object)  
            {  
                Thread.Sleep(100);  
                Console.WriteLine(Environment.TickCount);  
            }  
        }  
  
        static void Main(string[] args)      
        {  
  
              
            Thread[] Threads = new Thread[3];  
            for (int i = 0; i < 3; i++)  
            {  
                Threads[i] = new Thread(new ThreadStart(PrintNumbers));  
                Threads[i].Name = "Child " + i;  
            }  
            foreach (Thread t in Threads)  
                t.Start();  
  
            Console.ReadLine();  
        }  
    }  
}

Output

In C# 4.0, overloaded function for Monitor.Enter(_object,ref _lockTaken) acquires an exclusive lock and the specified object, and automatically sets a value that indicates whether the lock was taken.

class Program  
{  
     static readonly object _object = new object();  
  
     public static void PrintNumbers()  
     {  
         Boolean _lockTaken = false;  
  
         Monitor.Enter(_object,ref _lockTaken);  
         try  
         {  
            for (int i = 0; i < 5; i++)  
            {  
               Thread.Sleep(100);  
               Console.Write(i + ",");  
            }  
            Console.WriteLine();  
         }  
         finally  
         {  
            if (_lockTaken)  
            {  
               Monitor.Exit(_object);  
            }  
         }  
     }
}

Important Sticky

The Monitor class is a static class and its instance cannot be created.

The Monitor class object uses the Monitor.Enter, Monitor.TryEnter, and Monitor.Exit methods. Once you have a lock on a code region, you can use the Monitor.Wait, Monitor.Pulse, and Monitor.PulseAll methods.

It is associated with an object on demand.

It is unbound, which means it can be called directly from any context.

Conclusion

Lock and monitor are basically used for the same purpose in multithreading. The difference is when we want more control over synchronization with multiple threads running for a specific section of code.