Deadlocks and Lock Mechanisms

Understanding Deadlocks and Lock Mechanisms

Welcome to the next step in your journey through Java concurrency! In this lesson, we will delve into the intricacies of deadlocks and lock mechanisms . Mastering these concepts is essential for building robust, error-free applications and ensuring your multi-threaded programs run smoothly.

What You'll Learn

By the end of this lesson, you will: Understand the concept of deadlocks and their causes. Learn techniques to prevent deadlocks through lock reordering. Gain proficiency in using ReentrantLock for improved control over locking. Understand the role of locks in managing shared resources. Let’s start by exploring the concept of locks in Java.

Locking in Java: Synchronized Blocks and "this" as a Lock

In previous lessons, we discussed synchronized(this), where the current instance of the class serves as the monitor object or lock. This is a type of intrinsic lock, meaning that every object in Java has an implicit lock. When a thread acquires this lock, it prevents other threads from entering synchronized sections of code for that object until the lock is released. For example: Java public void increment() {synchronized (this) {// Critical section count++;}} In the code above, the lock on this ensures that only one thread at a time can execute this critical section on the given instance of the class. This helps prevent race conditions and ensures consistent updates to shared data.

Locks in Java

Locks are mechanisms used to synchronize access to shared resources in multi-threaded programs. When a thread acquires a lock, it prevents other threads from accessing the locked resource until it is released. The synchronized keyword is Java’s built-in mechanism for managing these intrinsic locks. Types of Locks in Java : Object Locks (synchronized(this) or synchronized(someObject)) : These are associated with an individual instance of an object. Only one thread can execute any synchronized method of that instance at a time. Class Locks (synchronized(ClassName.class)) : These are used to lock at the class level, preventing multiple threads from executing static synchronized methods simultaneously. Using locks correctly can help manage access to shared resources, but it also comes with the risk of deadlocks if not used properly.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Deadlocks in Action

Here's an example of a deadlock scenario:

Java

public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void methodOne() {
        synchronized (lock1) {
            System.out.println("Thread 1 acquired lock1");
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            synchronized (lock2) {
                System.out.println("Thread 1 acquired lock2");
            }
        }
    }

    public void methodTwo() {
        synchronized (lock2) {
            System.out.println("Thread 2 acquired lock2");
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            synchronized (lock1) {
                System.out.println("Thread 2 acquired lock1");
            }
        }
    }
}

public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void methodOne() {
        synchronized (lock1) {
            System.out.println("Thread 1 acquired lock1");
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            synchronized (lock2) {
                System.out.println("Thread 1 acquired lock2");
            }
        }
    }

    public void methodTwo() {
        synchronized (lock2) {
            System.out.println("Thread 2 acquired lock2");
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            synchronized (lock1) {
                System.out.println("Thread 2 acquired lock1");
            }
        }
    }
}

Here's how you can run this deadlock scenario:

Java

public class Main {
    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread t1 = new Thread(example::methodOne);
        Thread t2 = new Thread(example::methodTwo);
        t1.start();
        t2.start();
    }
}

public class Main {
    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread t1 = new Thread(example::methodOne);
        Thread t2 = new Thread(example::methodTwo);
        t1.start();
        t2.start();
    }
}

In this example, there are two locks (lock1 and lock2). Thread 1 acquires lock1 first and then tries to acquire lock2. At the same time, Thread 2 acquires lock2 first and then tries to acquire lock1. This creates a circular dependency:

Thread 1: Holds lock1 and waits for lock2.
Thread 2: Holds lock2 and waits for lock1.

Since both threads are waiting for each other to release the resources they need, neither can proceed, resulting in a deadlock.

This example helps illustrate how easy it is for deadlocks to occur when multiple threads are acquiring multiple locks in inconsistent orders.

Using ReentrantLock as an Alternate Solution

Java also provides a more advanced locking mechanism with the ReentrantLock class, part of the java.util.concurrent.locks package. Unlike the synchronized keyword, ReentrantLock offers greater flexibility, such as the ability to try acquiring a lock without blocking forever or to interrupt a thread waiting for a lock.

To illustrate the flexibility and control provided by ReentrantLock, here’s an example of managing locks explicitly in a multi-threaded context:

Java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void methodOne() {
        lock1.lock();
        try {
            System.out.println("Thread 1 acquired lock1");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            lock2.lock();
            try {
                System.out.println("Thread 1 acquired lock2");
            } finally {
                lock2.unlock();
            }
        } finally {
            lock1.unlock();
        }
    }

    public void methodTwo() {
        lock1.lock(); // Consistent lock order
        try {
            System.out.println("Thread 2 acquired lock1");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            lock2.lock();
            try {
                System.out.println("Thread 2 acquired lock2");
            } finally {
                lock2.unlock();
            }
        } finally {
            lock1.unlock();
        }
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void methodOne() {
        lock1.lock();
        try {
            System.out.println("Thread 1 acquired lock1");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            lock2.lock();
            try {
                System.out.println("Thread 1 acquired lock2");
            } finally {
                lock2.unlock();
            }
        } finally {
            lock1.unlock();
        }
    }

    public void methodTwo() {
        lock1.lock(); // Consistent lock order
        try {
            System.out.println("Thread 2 acquired lock1");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            lock2.lock();
            try {
                System.out.println("Thread 2 acquired lock2");
            } finally {
                lock2.unlock();
            }
        } finally {
            lock1.unlock();
        }
    }
}

In this example, we use ReentrantLock instead of synchronized to explicitly control the locking process.

Acquiring the Lock: The lock() method acquires the lock for the current thread, preventing others from entering the critical section.
Releasing the Lock: The unlock() method releases the lock, allowing other threads to acquire it.
Consistent Lock Order: We still acquire lock1 before lock2, ensuring that deadlocks do not occur.

Understanding Deadlocks and Lock Mechanisms

What You'll Learn

Locking in Java: Synchronized Blocks and "this" as a Lock

Locks in Java

Join the 1M+ learners on CodeSignal

What is a Deadlock?

Deadlocks in Action

Preventing Deadlocks by Reordering Locks

Using ReentrantLock as an Alternate Solution

The tryLock() Method

Importance of Deadlock Prevention

Ready to Practice?