Differences between Lock and Monitor in Java Concurrency

In this tutorial, we will discuss the overview of Lock and Monitor and the differences between them.

Introduction

Java Concurrency is the ability to perform specific tasks at a time parallelly. The Java Programming language deals with multithreading and other concurrent classes or concepts. It is mainly used to ensure the overall and efficient performance of the CPU by reducing its idle time. Two significant concepts must learn while discussing java concurrency. They are locks and monitors. A lock is well known as Mutex. Locks have been in presence to carry out multithreading much before the monitor has come to use. If we come back, the locks or Mutex were portions of threads inside the program that worked on the flag mechanism to synchronize with other threads. Locks have always worked as a simple tool which gives synchronization access to control over all resources and objects. With additional progressions, the utilization of monitor began as a system to deal with the access and coordinate thread, which ended up being more productive, error-free, efficient, and viable in object-situated programs. Before we continue to find the distinctions between the two, we should have a more intensive investigation of every one of them.

Lock or Mutex

Lock initially has been utilized in the legitimate part of the threads that were used to give synchronized access control between the threads. Threads checked the accessibility of access command over shared objects through flags joined to the article that showed whether the common asset is free (unlocked) or occupied (locked). Presently the concurrency API (Application Programming Interface) offers the help of utilizing locks unequivocally involving Lock Interface in Java. The precise technique has a better control mechanism when contrasted with the understood execution of locks using monitors. Before we continue to examine monitors, let us take an illustration at a representation that exhibits the working of essential locks.

Monitor

Monitor in Java Concurrency is a synchronization system that gives the central necessities of multithreading shared mutual exclusion between different threads and participation among threads working at typical tasks. Monitors essentially 'monitor' the entrance control of divided or shared resources and items between threads. Using this development, just a single thread at a time gets access command over the primary segment at the help. In contrast, other threads are obstructed and made to hold on until specific circumstances. In JavaJava, monitors are implemented using synchronized keywords (synchronized blocks, methods or classes). For example, we should perceive how two strings, t1 and t2, are synchronized to utilize an ordinary information printer object.

Program:

//program for understanding the working of Monitor in Java Concurrency
 
import java.io.*;
 
class SDP
 {
 
    // Monitor implementation using synchronized method
 
    synchronized public void display (String str)
    {
 
        for (int i = 0; i < str.length(); i++) {
            System.out.print(str.charAt(i));
 
            // try and catch block since we are using the sleep() method
           
       try {
 
                // Making sleep for a few nanoseconds, which passes as arguments
                Thread.sleep(100);
            }
            catch (Exception e) {
            }
        }
    }
}
 
// Class 2
// class for extending thread


class Thread1 extends thread {
 
    SDP j;
 
    // Thread
    public Thread1(SDP j)
    {
 
        // Here, we are using the 'this' keyword to refer to the current instance
        this.j = j;
    }
 
    // using the run() method to invoke the thread
    // start() method is called from the main method to start a thread
    public void run()
    {
 
        // Displaying statement
        j.display("Tutorialandexample");
    }
}
 
// creating another thread class similar to thread1 by extending the Thread class
class Thread2 extends thread {
 
    SDP j;
 
    public Thread2(SDP j) { this.j = j; }
 
    public void run()
    {
 
        // Displaying a message
        j.display(" Tutorial");
    }
}
 
// Main class
class Jtp 
{
 
    // Main method
    public static void main (String s[])
    {
 // instance of the shared resource which is used to display string
//( as a single character at a time)
        
        SDP printer = new SDP();
 
        // Instances of the thread objects by sharing the printer
        Thread1 t1 = new Thread1(printer);
        Thread2 t2 = new Thread2(printer);
 
        // Calling start method to both the instances
        t1.start();
        t2.start();
    }
}

Output:

Tutorialandexample tutorial