如何使用这两个线程以及类A和B的对象创建死锁？

Question

public class DeadLock {

    public static void main(String[] args) {

        final A a = new A();
        final B b = new B();

        new Thread(new Runnable(){
            @Override
            public void run() {
                 a.aMethod(b);
                }
        },"Thread-2").start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                b.bMethod(a);
            }
        },"Thread-2").start();
    }
}

class A {
    public  void aMethod(B b) {
        System.out.println("A method");
    }
}

class B {
    public  void bMethod(A a) {
        System.out.println("B method");
    }
}

I understand that Deadlock occurs when two or more threads are blocked waiting for each other. How do I implement the same using the code above? Synchronizing the methods in classes A and B doesn't help.

Answer 1

How do I implement the same using the code above? Synchronizing the methods in classes A and B doesn't help.

The definition of deadlock is that A is locked and needs the lock from B at the same time that B is locked and needs the lock from A .

You aren't going to be able to simulate it with a single thread call because likely the first thread that is started will finish before the second thread starts. This is ar ace condition where the threads are racing to deadlock or not.

You need to loop in both threads and try the dual lock over and over. Something like the following should work. At some point you will see the output stop.

public void run() {
   while (true) {
     a.aMethod(b);
   }
}
...
public void run() {
   while (true) {
     b.bMethod(a);
   }
}
...
public synchronized void aMethod(B b) {
    System.out.println("B method");
    b.bMethod(this);
}
...
public synchronized void aMethod(A a) {
    System.out.println("A method");
    a.aMethod(this);
}

You may also have to remove the System.out.println(...) calls because they also are synchronized which will change the timing of your program and may make it harder to hit a deadlock. Without the output, to detect the deadlock without the output you can attach to the process using jconsole, look at the Threads tab, and click "Detect Deadlock". You can also watch the load of your program. It should be ~200% while 2 threads are spinning and then go to 0 when they are deadlocked.

Answer 2

public static void main(String[] args) {
    final Object a = new Object();
    final Object b = new Object();

    Thread t1 = new Thread() {
        @Override
        public void run() {
            synchronized (a) {
                try {
                    sleep(10000);
                } catch (InterruptedException exc) {
                    // 
                }
                synchronized (b) {
                    //
                }
            }
        }
    };

    Thread t2 = new Thread() {
        @Override
        public void run() {
            synchronized (b) {
                try {
                    sleep(10000);
                } catch (InterruptedException exc) {
                    // 
                }
                synchronized (a) {
                    //
                }
            }
        }
    };
    t1.start();
    t2.start();
}