How can create a deadlock scenario in Java

Table of Contents

Introduction:

let’s create a simplified example illustrating a deadlock scenario in a social media context. In this scenario, we have two users, User A and User B, who want to like each other’s posts. However, liking a post requires acquiring locks on both users’ accounts, potentially leading to a deadlock if not handled properly.

Scenario:

Imagine a social media platform where users can like each other’s posts. User A wants to like User B‘s post, and at the same time, User B wants to like User A‘s post. To like a post, a user needs to acquire a lock on the corresponding user’s account. However, if User A holds a lock on User A’s account while waiting to acquire a lock on User B‘s account, and User B holds a lock on User B’s account while waiting to acquire a lock on User A‘s account, a deadlock can occur.

Code Example:

public class SocialMediaDeadlock {
    private static final Object lockUserA = new Object();
    private static final Object lockUserB = new Object();

    public static void main(String[] args) {
        // Thread for User A
        Thread userAThread = new Thread(() -> {
            // Acquire lock on User A's account
            synchronized (lockUserA) {
                System.out.println("User A: Acquired lock on User A's account.");
                try {
                    Thread.sleep(100); // Simulate some work
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("User A: Waiting to like User B's post...");
                // Attempt to acquire lock on User B's account
                synchronized (lockUserB) {
                    System.out.println("User A: Liked User B's post.");
                }
            }
        });

        // Thread for User B
        Thread userBThread = new Thread(() -> {
            // Acquire lock on User B's account
            synchronized (lockUserB) {
                System.out.println("User B: Acquired lock on User B's account.");
                try {
                    Thread.sleep(100); // Simulate some work
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("User B: Waiting to like User A's post...");
                // Attempt to acquire lock on User A's account
                synchronized (lockUserA) {
                    System.out.println("User B: Liked User A's post.");
                }
            }
        });

        // Start User A's thread
        userAThread.start();
        // Start User B's thread
        userBThread.start();
    }
}

/**
Output: 
User A: Acquired lock on User A's account.
User B: Acquired lock on User B's account.
User A: Waiting to like User B's post...
User B: Waiting to like User A's post...

*/

Java

Explanation:

We have two lock objects, lockUserA and lockUserB, representing the accounts of User A and User B, respectively.
Two threads, one for User A and one for User B, are created to simulate their actions.
Each thread attempts to acquire locks on both users’ accounts. If executed concurrently, this can lead to a potential deadlock where neither thread can proceed further.

Conclusion:

This example demonstrates how a deadlock scenario can arise in a social media context when multiple resources need to be accessed and shared among different entities. It highlights the importance of proper synchronization and resource management in multithreaded applications to avoid deadlock situations.