The key to avoiding deadlocks is to understand the conditions for their occurrence and adopt appropriate strategies to avoid evasion, which includes the following 4 methods: 1. Unify the locking order to ensure that all threads acquire locks in the same order, thereby avoiding loop waiting; 2. Use explicit lock ReentrantLock and set the timeout time, try to acquire locks through the tryLock() method to avoid indefinite waiting; 3. Reduce the granularity and scope of use of the lock, only lock the key parts, try to use local variables and concurrent collection classes to reduce the probability of conflict; 4. Use tools such as jstack, VisualVM, etc. to detect potential deadlocks, and promptly identify and solve thread blocking problems.

In Java multithreaded programming, deadlock is a common but easily overlooked problem. It usually occurs when multiple threads are waiting for each other's resources, causing the program to be stuck and unable to continue execution. The key to avoiding deadlocks is to understand the conditions in which they occur and adopt appropriate strategies to circumvent.

1. Avoid nested locking (Lock Ordering)

Most deadlock problems arise from multiple threads acquiring multiple locks in different orders. For example, if thread A acquires lock 1 first and then lock 2, and thread B acquires lock 2 first and then lock 1, a deadlock may occur.

Solution: Unified locking order

As long as all threads acquire locks in the same order, this loop waiting situation can be effectively avoided. For example, it is stipulated that the lock with a smaller number is always acquired first, and then the lock with a larger number is obtained.

For example:

 // Thread 1
synchronized(lockA) {
    synchronized(lockB) {
        // do something
    }
}

// Thread 2 (if it is also in the same order, there will be no conflict)
synchronized(lockA) {
    synchronized(lockB) {
        // do something else
    }
}

In this way, the two threads will not experience cross-wait, thereby avoiding deadlocks.

2. Use an explicit lock and set the timeout (Try-with-timeout)

Java provides a more flexible lock mechanism like ReentrantLock , which supports trying to acquire locks and setting timeouts. This method can actively give up when the lock is not acquired, rather than waiting indefinitely.

Suggested practices:

• Use tryLock() method instead of synchronized
• Set reasonable waiting time to avoid permanent blockage

Sample code:

 ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

boolean acquired1 = lock1.tryLock();
boolean acquired2 = false;

if (acquired1) {
    try {
        acquired2 = lock2.tryLock(500, TimeUnit.MILLISECONDS);
    } finally {
        if (!acquired2) lock1.unlock();
    }
}

If the second lock cannot be acquired within the specified time, you can free up the acquired resource and try again or exit to avoid falling into a deadlock state.

3. Reduce Lock Scope

Many times, for simplicity and convenience, we will directly lock the entire method or use a large range of synchronization blocks, which not only affects performance, but also increases the risk of deadlock.

Optimization direction:

• Move code that does not need to be synchronized out of the synchronization block
• Try to use local variables instead of shared resources
• Use concurrent collection classes (such as ConcurrentHashMap ) instead of manual locking

for example:

 // Not recommended practice synchronized void badMethod() {
    // Do a lot of operations that do not involve sharedResource.doSomething();
}

// Better writing method void betterMethod() {
    // Only lock the key parts synchronized(sharedResource) {
        sharedResource.doSomething();
    }
}

The smaller the range of the lock, the shorter the time it holds the lock, the lower the probability of conflict.

4. Use Tools to Detect

Even if you have been dealing with multi-threaded logic carefully, there may be omissions. At this time, you can use some tools to help check potential deadlock risks:

• JVM comes with jstack tool : it can print thread stacks to identify which threads are waiting and which lock they are waiting for.
• VisualVM or JConsole : Graphical tool that can monitor thread status in real time and even automatically prompt for possible deadlocks.
• IDE plug-in or static analysis tool : such as IntelliJ's thread analysis function, can also give prompts during the encoding stage.

Run command example:

 jstack <pid> | grep -i deadlock

This command can help you quickly locate whether there is a deadlock.

Basically that's it. Although deadlocks may seem a bit complicated, as long as you pay attention to the locking order, reduce the lock range, use explicit locks reasonably, and combine with tool troubleshooting, it can greatly reduce its probability of occurrence.

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