Нужны советы о том, как избежать тупика

Question

У меня в приложении есть ситуация, подобная этой:

public class Example {

private static A aClass = new A();
private static B bClass = new B();

public static void main(String[] args) {

    new Thread(new Runnable() {
        @Override
        public void run() {
            bClass.start();
        }
    }, ">>>>>>>>>>").start();


    new Thread(new Runnable() {
        @Override
        public void run() {
            aClass.start();
        }
    }, "__________").start();

    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    detectDeadlock();
}

private static void detectDeadlock() {
    ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
    long[] threadIds = threadBean.findMonitorDeadlockedThreads();
    int deadlockedThreads = threadIds != null? threadIds.length : 0;
    System.out.println("Number of deadlocked threads: " + deadlockedThreads);
}

private static class A {
    private final Object aLock = new Object();

    public void start() {
        System.out.println(Thread.currentThread()+ " " + "A-start; waiting for aLock");
        synchronized (aLock) {
            System.out.println(Thread.currentThread()+ " " + "A-start; acquired aLock");
            bClass.synchronizedMethod();
        }
        System.out.println(Thread.currentThread()+ " " + "A-start; release aLock");
    }

    public void synchronizedMethod() {
        System.out.println(Thread.currentThread()+ " " + "A-synchronizedMethod; waiting for aLock");
        synchronized (aLock) {
            System.out.println(Thread.currentThread()+ " " + "A-synchronizedMethod; acquired aLock");
        }
        System.out.println(Thread.currentThread()+ " " + "A-synchronizedMethod; release aLock");
    }
}

private static class B {
    private final Object bLock = new Object();

    public void synchronizedMethod() {
        System.out.println(Thread.currentThread()+ " " + "B-synchronizedMethod; waiting for bLock");
        synchronized (bLock) {
            System.out.println(Thread.currentThread()+ " " + "B-synchronizedMethod; acquired bLock");
        }
        System.out.println(Thread.currentThread()+ " " + "B-synchronizedMethod; release bLock");
    }

    public void start() {
        System.out.println(Thread.currentThread() + " " + "B-Start; waiting for bLock");
        synchronized (bLock) {
            System.out.println(Thread.currentThread()+ " " + "B-Start; acquired bLock");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            aClass.synchronizedMethod();
        }
        System.out.println(Thread.currentThread()+ " " + "B-Start; released bLock");
    }
}

}

вывод для этого фрагмента будет примерно таким:

Thread[>>>>>>>>>>,5,main] B-Start; waiting for bLock
Thread[>>>>>>>>>>,5,main] B-Start; acquired bLock
Thread[__________,5,main] A-start; waiting for aLock
Thread[__________,5,main] A-start; acquired aLock
Thread[__________,5,main] B-synchronizedMethod; waiting for bLock
Thread[>>>>>>>>>>,5,main] A-synchronizedMethod; waiting for aLock
Number of deadlocked threads: 2

Я ищу руководство для этой тупиковой ситуации.

Подскажите, пожалуйста, как избежать этого тупика?

Answer 1

В итоге я решил использовать глобальную блокировку, которая будет использоваться обоими экземплярами A и B.

Код будет выглядеть примерно так:

 private static class Lock {
    private static Lock lock = new Lock();
    private Lock(){}
    public static Lock getLock() {return lock;}
}

private static class A {
    private final Object aLock = Lock.getLock();
    // ...
}

private static class B {
    private final Object bLock = Lock.getLock();
    // ...
}