两个锁的死锁的可能性？

Question

当线程1调用one，线程2调用two时，代码会死锁吗？也就是说，内部锁的获取是否可以重新排序到外部锁的获取之前(从另一个线程的POV )？

private final Object foo = new Object();
synchronized  void one() {
    // ...
    synchronized(this.foo) {
       // ...
    }
    // ...
}

synchronized void two() {
    // ...
    synchronized(this.foo) {
       // ...
    }
    // ...
}

Answer 1

不，这不会死锁。

当调用同步的方法时，this的固有锁在方法体执行之前被锁定。在这里，线程1或线程2将运行其方法，而另一个线程将无法锁定this.foo的固有锁，因此this锁的所有者将能够锁定this.foo。

Answer 2

因此，对于一个简单的测试：

class LockTest implements Runnable {
    public final Object foo = new Object();
    boolean runOne;

    public LockTest(boolean runOne) {
        this.runOne = runOne;
    }

    synchronized void  one() {
        System.out.println("runnin one function");
        synchronized(this.foo) {
            try {
                System.out.println("Enter Sleep function one");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    synchronized void  two() {
        System.out.println("running two function");
        synchronized(this.foo) {
            try {
                System.out.println("enter sleep function two");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        if(runOne)
        one();
        else
            two();
    }
}

在主类中使用以下代码：

while (true)
        {
            LockTest document2 = new LockTest(true);
            LockTest document3 = new LockTest(false);
            Thread tread1 = new Thread(document2);
            Thread tread2 = new Thread(document3);
            tread1.start();
            tread2.start();
            a++;
            if(a==10)
                break;

        }

我们没有锁定，甚至没有使用线程转储进行监视，一切都正常。为什么？因为每次我们用新对象foo初始化一个新的Thread。但是如果该对象被声明为静态的，那么它将是一个锁，其他线程需要等待。所以从我的测试和POV来看。不，它不会死锁的。