C# Monitor class in multithreading with examples

Last updated on December 29th, 2021 at 12:46 am

What Is Monitor Class In C#?

C# Monitor: The Monitor class in C# provides a wait-based synchronization mechanism that allows only one thread to access a critical section of code at a time to avoid the race condition.
All the other threads have to wait and halt the execution until the locked object is released.

The  Monitor.Enter  method is used to acquire an exclusive lock on the object whereas  Monitor.Exit  method is used to release the locked object.

In order to use the Monitor class in a multithreading , we first need to import the  System.Threading  namespace.

C# Monitor Syntax

The following is the syntax to declare monitor class in C#

static object _lock = new object();
// Lock object
Monitor.Enter(_lock);
try
{
  // Critical piece of code
}

finally
{
 // Releasing object
   Monitor.Exit(_lock);
}

Example: C# Monitor Class in Multithreading

Following is the example of the Monitor class in C#

using System;
using System.Threading;
namespace MontitorExample
{
 class Program
  {
 static object _lock = new object();

 public static void PrintNumber()
  {   
  // Lock object

  Monitor.Enter(_lock);
  try
   {
    // Critical piece of code
              
    int threadId = Thread.CurrentThread.ManagedThreadId;
    Console.WriteLine($" Thread: {threadId} Entered into the critical section ");

    for (int num = 1; num <= 3; num ++)
     {

      Console.WriteLine($" num: {num}");
    //Pausing the thread execution for 2 seconds

      Thread.Sleep(TimeSpan.FromSeconds(2));

      }
   }

  catch (SynchronizationLockException exception)
      {
       Console.WriteLine(exception.Message);
      }

  finally
    { 
     // Releasing object
      Monitor.Exit(_lock);
      Console.WriteLine($"Thread : {Thread.CurrentThread.ManagedThreadId} Released");
    }           
  }
  static void Main(string[] args)
   {        
   // Creating threads
   Thread thread1 = new Thread(PrintNumber);
   Thread thread2 = new Thread(PrintNumber);

  // Executing the threads
   thread1.Start();
   thread2.Start();

  Console.ReadLine();      
   }
 }

}

Let’s run the above program to see the result.

Methods of the Monitor class

The Monitor class is a static class which contains the following methods:

• • • Monitor.Enter
    • Monitor.TryEnter
    • Monitor.Exit
    • Monitor.Pulse
    • Monitor.PulseAll
    • Monitor.Wait

Monitor.Enter, Monitor.TryEnter : These methods are used to acquire an exclusive lock on the object, which allows only one thread to access the critical section of code at a time.

Monitor.Pulse, Monitor.PulseAll : A thread sends the signal to one or multiple threads in the waiting queue that the state of the locked object has been changed. So, that they can proceed with the further process.

Monitor.Wait(): This method is used to release the locked object after getting the Pulse notification to allow other threads to lock and access the object.

The calling threads wait in the waiting queue while the other thread is allowed to access the object until it gets the pulse notification.

Note: Wait() method must execute before the Pulse or PulseAll method to get the pulse notification.

Monitor.Exit: This method is used to release the locked object, and it is always declared inside finally block.

Difference between Lock and Monitor in C#

In C#, Both the  Lock  and  Monitor   class are basically used to ensure that only one thread can access a particular section of code at a time. 

The following are the basic differences between both classes:

• • A lock statement is a short form of the Monitor class which internally wraps the methods  Monitor.Enter  and  Monitor.Exit  with an additional  try/finally  block, to perform the thread-safe operation, whereas in the case of Monitor class, we have to declare try and finally block explicitly to  release the locked object.

• • Apart from the synchronization mechanism, the Monitor class provides some useful methods like Wait(), Pulse(), and PulseAll() for the signaling mechanism between the threads. However, the lock doesn’t support the signaling mechanism.
  • The monitor is a static class that can’t be instantiated.

FAQ

Conclusion

In C#, The Lock and Monitor classes are generally used for synchronization purposes in a multithreading environment.
They allow only one thread to access a critical section of code at a time.
The only major difference between both of them is that the Monitor class provides more control over synchronization by using the signaling mechanism.

Thank you for taking the time to read the blog, if you find it interesting, please like, comment, and share it with others.

Articles to Check Out

• • C# 10 New features with examples | What’s new in C# 10?
  • C# Abstract class Vs Interface
  • C# Array vs List: When should you use an array or a List?
  • Generic Delegates in C# With Examples
  • IEnumerable Interface in C# with examples
  • Constructors in C# with Examples
  • C# Enum | How to Use enumeration type in C#?
  • Properties In C# with examples
  • Multithreading in C#
  • IEnumerable Interface in C# with examples
  • C# List Class With Examples
  • C# Monitor class in multithreading
  • C# Struct vs Class
  • C# Dictionary with Examples

• Author
• Recent Posts

Shekh Ali

Meet Shekh Ali, a skilled Software engineer and passionate blogger with an MCA degree and 8+ years of experience in the field. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Shekh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• SQL Server Indexing: Clustered vs Non Clustered Index Explained - March 26, 2023
• Mastering Database Normalization: Best Practices and Techniques - March 25, 2023
• CRM Databases: The Key to Enhanced Customer Engagement and Sales - March 23, 2023