Difference Between Lock and Monitor in Java Concurrency

Lock

Locks in Java are synchronization primitives, used to control access to shared resources or critical sections of code to ensure that only one thread can access them at a time.

A lock is a simple synchronization construct that allows one thread to acquire a lock on a resource. Once a thread has acquired a lock on a resource, the first thread can acquire the lock once the first thread releases it.

Locks ensure that only one thread can access a protected resource at a time, preventing race conditions and data corruption.

Java provides several mechanisms for implementing locks, with the most commonly used one being the 'ReentrantLock' class from the java.util.concurrent.locks package. Here's an overview of locks in Java concurrency:

1. ReentranLock

ReentrantLock in Java is a synchronization mechanism that allows a thread to acquire the same lock multiple times without blocking itself. It is useful for situations where a thread needs to access a shared resource that is protected by a lock.

ReentrantLock provides several methods for locking and unlocking, including lock(), unlock(), tryLock(), and newCondition().

It allows for finer-grained control over synchronization compared to synchronized blocks or methods.

ReentrantLockExample.java

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        // Create two threads that access the shared resource
        Thread thread1 = new Thread(() -> {
            resource.performTask("Thread 1");
        });
        Thread thread2 = new Thread(() -> {
            resource.performTask("Thread 2");
        });
        // Start both threads
        thread1.start();
        thread2.start();
    }
}
class SharedResource {
    private final ReentrantLock lock = new ReentrantLock();
    public void performTask(String threadName) {
        lock.lock(); // Acquire the lock
        try {
            System.out.println(threadName + " is performing a task.");
            Thread.sleep(1000); // Simulate some work
            System.out.println(threadName + " has completed the task.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // Release the lock
        }
    }
}

Output:

Thread 1 is performing a task.
Thread 1 has completed the task.
Thread 2 is performing a task.
Thread 2 has completed the task.

In this example, the doSomething() method acquires the lock before accessing the shared resource. When the method is finished with the resource, it releases the lock.

2. Lock Interfaces

Java provides various lock interfaces, such as Lock, ReadWriteLock, and Condition, allowing us to choose the right type of lock for our specific concurrency needs.

3. Exception Handling

Locks should be used within try-finally blocks to ensure proper lock release, even in the presence of exceptions.

It is important to prevent resource leaks and ensure that other threads can access the locked resource once the current thread is done.

4. Concurrent Collection

Many classes in the java.util.concurrent package uses locks internally to provide thread-safe collections, such as ConcurrentHashMap and CopyOnWriteArrayList.

Monitor

In Java concurrency, a monitor is a synchronization concept that is associated with objects and methods. It provides fundamental requirements of multithreading.

A monitor is a synchronization mechanism that allows threads to have:

Mutual exclusion- Only one thread can execute the method at a certain point in time, using locks.

Cooperation - The ability to make threads wait for certain conditions to be met using wait-set.

Monitors basically 'monitor' the access control of shared resources and objects among threads.

1. Synchronized Methods

We can declare a method as synchronized in Java to make it a synchronized method. When a thread enters a synchronized method, it acquires the monitor associated with the object instance.

2. Synchronized Blocks

In addition to synchronized methods, we can use synchronized blocks to protect specific sections of code. It allows for more fine-grained control over synchronization.

SynchronisedBlockExample.java

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized void decrement() {
        count--;
    }
    public synchronized int getCount() {
        return count;
    }
}
public class SynchronisedBlockExample{
    public static void main(String[] args) {
        Counter counter = new Counter();
        // Create two threads to increment and decrement the counter
        Thread incrementThread = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });
        Thread decrementThread = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.decrement();
            }
        });
        // Start both threads
        incrementThread.start();
        decrementThread.start();
        try {
            // Wait for both threads to finish
            incrementThread.join();
            decrementThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Print the final count
        System.out.println("Final Count: " + counter.getCount());
    }
}

Output:

Final Count: 0

3. Intrinsic Lock

In Java, each object has an intrinsic lock, also known as a monitor lock. It allows a thread to acquire exclusive Access to an object. It means that only one thread can be executing code that is synchronized on the object at a time. Intrinsic locks are used to prevent race conditions.

To acquire an intrinsic lock, a thread calls the synchronized() method. The synchronized() method takes an object as its argument. The thread then acquires the intrinsic lock for the object. Once the thread has acquired the lock, it can execute the synchronized code without worrying about other threads interfering.

When the thread is finished executing the synchronized code, it must release the intrinsic lock. The thread calls the synchronized() method again, this time with the false argument. The false argument tells the synchronized() method to release the lock.

IntrinsicLockExample.java

public class IntrinsicLockExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        // Create two threads that access the shared resource concurrently
        Thread thread1 = new Thread(() -> {
            resource.performTask("Thread 1");
        });
        Thread thread2 = new Thread(() -> {
            resource.performTask("Thread 2");
        });
        // Start both threads
        thread1.start();
        thread2.start();
    }
}
class SharedResource {
    public synchronized void performTask(String threadName) {
        System.out.println(threadName + " is performing a synchronized task.");
        try {
            Thread.sleep(2000); // Simulate some work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(threadName + " has completed the task.");
    }
}

Output:

Thread 1 is performing a synchronized task.
Thread 1 has completed the task.
Thread 2 is performing a synchronized task.
Thread 2 has completed the task.

4. Ensuring Thread Safety

Monitors are used to ensure thread safety when multiple threads access shared data or resources concurrently.

By synchronizing methods or blocks, you can prevent race conditions, data corruption, and other concurrency issues.

5. Deadlock

Deadlocks occur when two or more threads are waiting for each other to release locks, causing the program to come to a standstill.

Proper design and careful use of synchronized blocks can help avoid deadlocks.

DeadlockExample.java

public class DeadlockExample {
    public static void main(String[] args) {
        // Two resources (locks)
        Object resource1 = new Object();
        Object resource2 = new Object();
        // Thread 1 acquires resource1, then waits to acquire resource2
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource1...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.println("Thread 1: Waiting for resource2...");
                synchronized (resource2) {
                    System.out.println("Thread 1: Acquired resource2.");
                }
            }
        });
        // Thread 2 acquires resource2, then waits to acquire resource1
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource2...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.println("Thread 2: Waiting for resource1...");
                synchronized (resource1) {
                    System.out.println("Thread 2: Acquired resource1.");
                }
            }
        });
        // Start both threads
        thread1.start();
        thread2.start();
        try {
            // Wait for both threads to finish
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Both threads have finished.");
    }
}

Output:

Thread 1: Holding resource1...
Thread 2: Holding resource2...
Thread 1: Waiting for resource2...
Thread 2: Waiting for resource1...

While monitors help prevent race conditions, it can also lead to deadlocks if not used carefully.

Key Differences Between Locks and Monitors

Lock	Monitor
Simple	Complex
No thread wait for conditions	Thread wait for conditions
A lock is used when synchronization is required.	Monitor is used when complex synchronization is required, such as when threads need to wait for conditions to be met.
Locks offer more control and flexibility but require explicit management.	While monitors are simpler to use but offer less fine-grained control.
Implemented by the Java Virtual Machine (JVM).	Implemented by the JVM using locks.
Used to protect shared resources from concurrent Access.	Used to protect shared resources from concurrent Access, as well as to coordinate the execution of multiple threads.