java - 模拟Java线程死锁

Question

是否可以通过多个线程共享一个对象来模拟Java死锁场景？

比如我有一个类

public class MyClass {

    public synchronized void syncInstanceMethod1(){
        /// Anything here to simulate a dead lock

    }
    public synchronized void syncInstanceMethod2(){
        /// Anything here to simulate a dead lock
    }
    public static synchronized void syncStaticMethod1(){
        /// Anything here to simulate a dead lock
    }
    public static synchronized void syncStaticMethod2(){
        /// Anything here to simulate a dead lock
    }

    public void instanceMethod1(){
        /// Anything here to simulate a dead lock
    }

    public void instanceMethod2(){
        /// Anything here to simulate a dead lock
    }


    public static void main(String[] args) {
        MyClass shared = new MyClass();  // Allowed to create only one instance

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {

                // Do whatever here to simulate dead lock like calling various methods on the shared object in any order

            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {

                // Do whatever here to simulate dead lock like calling various methods on the shared object in any order

            }
        });

        // Allowed to create more threads like above. t3 , t4 etc...

       t1.start();
       t2.start();
    }

}

也许这是不可能的。由于可能发生死锁的常见情况是一个代码块，它在其中获取一个对象的锁并且在不释放它的情况下尝试获取另一个对象的锁。

我们可以通过调用静态同步方法从其中一个同步实例方法模拟这种情况，即尝试在锁定“this”的同时锁定“class”对象。但是要发生死锁，我们需要在其他地方以相反的顺序出现类似的情况。

此外，由于静态方法不能访问'this'，它不能锁定'this'，并且两个同步实例方法不能同时运行，这些事情让人相信我们不能在这里模拟死锁。我说得对吗？

Answer 1

尽管您只被要求创建一个实例，线程仍然有两个锁需要争用。实例方法需要线程获取 MyClass 对象实例上的锁，即 shared 或 this，具体取决于您如何看待它。

另一方面，静态方法需要线程获取 MyClass.class class 对象实例上的锁；你从 this.getClass() 得到的。

因此，如果线程 A 已经在执行一个同步实例方法(在 this 上有一个锁)并试图进入其中一个同步静态方法，而另一个线程 B 也已经在执行一个静态方法(在 MyClass.class 上有一个锁)现在试图进入同步实例方法在同一个 MyClass 对象上，死锁将发生。

下面是一些模拟这种情况的代码。

public class SingleObjectDeadlock {

    public synchronized void syncInstanceMethod1() {
        System.out.println("In syncInstanceMethod1()");
        syncStaticMethod2();
    }

    public synchronized void syncInstanceMethod2() {
        System.out.println("In syncInstanceMethod2()");
    }

    public static synchronized void syncStaticMethod1(SingleObjectDeadlock shared) {
        System.out.println("In syncStaticMethod1()");
        shared.syncInstanceMethod2();
    }

    public static synchronized void syncStaticMethod2() {
        System.out.println("In syncStaticMethod2()");
    }

    public static void main(String[] args) {
        SingleObjectDeadlock shared = new SingleObjectDeadlock();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                shared.syncInstanceMethod1();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleObjectDeadlock.syncStaticMethod1(shared);
            }
        });

        t1.start();
        t2.start();

        System.out.println("DEADLOCK!");
    }
}

运行时你会发现发生死锁并且程序永远不会打印

In syncStaticMethod2()
In syncInstanceMethod2()