How to prevent and deal with deadlocks in Java concurrent programming?

Deadlock is a common problem in concurrent programming and can be prevented or handled by taking measures: Preventing deadlock: - Acquire locks in order - Avoid circular waiting - Use timeout mechanism - Use non-blocking data structures to handle deadlock: - Dead Lock detection-deadlock recovery-retry operation

Deadlock prevention and processing in Java concurrent programming

Deadlock is A common problem you may encounter in concurrent programming is that multiple threads wait for each other to release resources, causing the system to deadlock. In Java, deadlocks can be prevented or handled by taking appropriate measures.

Prevent deadlock

• Acquire locks in order: Define an order for the resources to be accessed and ensure that all threads Locks are acquired in this order. For example, if thread A needs to access resources X and Y, and thread B needs to access resources Y and Z, then all threads should first acquire the lock on X and then the lock on Y.
• Avoid circular waiting: Ensure that a thread does not try to acquire the lock again while waiting for another thread to release the lock. For example, if thread A is waiting for thread B to release the lock on resource X, thread A should not try to acquire the lock on X again.
• Use the timeout mechanism: Set a timeout for the thread to acquire the lock. If the thread cannot acquire the lock within the specified time, it should give up the lock and try another method.
• Use non-blocking data structures: Using non-blocking data structures such as ConcurrentHashMap can reduce the possibility of deadlock. These data structures allow threads to access data simultaneously without using locks.

Handling Deadlocks

If precautions do not prevent deadlocks, you can handle deadlocks by:

• Deadlock detection: Use lock monitoring tools or custom detection mechanisms to identify deadlocks.
• Deadlock recovery:Once a deadlock is detected, the system can be recovered by releasing the locked resource or interrupting one of the threads involved in the deadlock.
• Retry deadlock: After releasing or interrupting the resource, you can retry the execution, which may avoid deadlock from happening again.

Practical case

Consider the following Java code snippet:

public class DeadlockExample {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock1) {
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample deadlockExample = new DeadlockExample();

        Thread thread1 = new Thread(deadlockExample::method1);
        Thread thread2 = new Thread(deadlockExample::method2);

        thread1.start();
        thread2.start();
    }
}

In this example, the two threads (thread1 and thread2) respectively Use lock1 and lock2 for synchronization. Since both threads acquire locks in reverse order, they wait for each other to release the lock, resulting in a deadlock.

To prevent deadlock, we can modify the code to acquire locks in order:

public class DeadlockExample {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
            synchronized (lock1) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample deadlockExample = new DeadlockExample();

        Thread thread1 = new Thread(deadlockExample::method1);
        Thread thread2 = new Thread(deadlockExample::method2);

        thread1.start();
        thread2.start();
    }
}

By modifying the code, we ensure that thread1 and thread2 always acquire in the same order (lock1 then lock2) lock to prevent deadlock.

The above is the detailed content of How to prevent and deal with deadlocks in Java concurrent programming?. For more information, please follow other related articles on the PHP Chinese website!