Question

Object o1 = new Object();
Object o2 = new Object();

线程1：

synchronized(o1){
    Thread.sleep(1000);
    synchronized(o2){
      //do something
    }
}

线程2：

synchronized(o2){
    Thread.sleep(1000);
    synchronized(o1){
      //do something
    }
}

测试代码：

new Thread1().start();
new Thread2().start();

以上代码总是死锁，如果没有，为什么？

Answer 1

是的，因为一旦线程被唤醒，它将无法进入下一个同步部分，因为已经锁定了。

（可能存在理论场景，其中不存在死锁 - 如果一个线程在第二个线程获得cpu时间之前获得两个锁，甚至获得第一个锁）

Answer 2

调用Thread1 import datetime; dt = datetime.datetime.now() print hex(dt.year) print hex(dt.month) print hex(dt.day) print hex(dt.hour) print hex(dt.minute) print hex(dt.second)和Thread2 A。 B表示第一个线程已锁定A1等。可能的操作顺序是

o1

因此，如果一个线程在第二个线程执行其第一个A1:A2:B2:B1 A1:B2 - deadlock on steps A2 and B1 B2:A1 - deadlock on steps B1 and A2 B2:B1:A1:A2块之前完成其操作，则代码不会死锁。当任一线程执行时由系统调度程序控制。

Answer 3

正确答案是“不。”

sleep()调用使得两个线程极有可能死锁，但它们保证两个线程将死锁。

您的“测试代码”线程启动“thread1”和“thread2”线程，如下所示：

new Thread1().start();
new Thread2().start();

如果两个线程在一秒内开始，那么你将陷入僵局。但是不能保证它会以这种方式出现。这是一个可能的序列化：

test code       thread1         thread2
---------       -------         -------
new Thread1
    .start()
...             lock o1
...             sleep(1000)
new Thread2     ...
    .start()    ...             waiting to run
                lock o2         ...
                do something    block on o2
                unlock o2       ...
                unlock o1       lock o2
                                sleep(1000)
                                lock o1
                                do something
                                unlock o1
                                unlock o2

为什么thread2在尝试锁定o2之前等了这么久？谁知道？也许系统负载很多其他进程。关键是，它不太可能以这种方式发生，但可能发生。因此，您的示例无法保证始终死锁。

以下java多线程示例总是死锁

3 个答案: