What methods can be used to prevent or eliminate deadlocks when using nested synchronized blocks?

Deadlock in Java when using nested synchronized blocks occurs when two or more threads try to acquire resources in different orders, and each waits for the resource held by the other.

Methods to prevent or resolve deadlocks:

1. Consistent lock acquisition order — always acquire multiple locks in the same order across all threads. This prevents cyclic waiting.

2. Using tryLock with timeout from java.util.concurrent.locks.Lock — allows attempting to acquire a lock and, if unsuccessful, releasing already acquired locks and retrying later, avoiding infinite waiting.

3. Minimize lock holding time — hold locks only on critical sections to reduce the likelihood of deadlocks.

4. Avoid nested locks if possible — refactor code to reduce the number of nested synchronized blocks.

Example of using tryLock:

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

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

public void safeMethod() {
    try {
        if(lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
            try {
                if(lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
                    try {
                        // critical section
                    } finally {
                        lock2.unlock();
                    }
                }
            } finally {
                lock1.unlock();
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

Thus, following lock acquisition order and using timeout mechanisms help prevent deadlocks.