编写一段代码，使其必定产生死锁

编写一段代码，使得这段代码必定会产生死锁
使用Thread.sleep

以下是一个经典的 Java 死锁实现，通过两个线程互相持有对方需要的锁来确保必定发生死锁：

1. public class DeadlockDemo {
2.     // 创建两个锁对象
3.     private static final Object lock1 = new Object();
4.     private static final Object lock2 = new Object();
5.    
6.     public static void main(String[] args) {
7.         // 线程1：先获取lock1，再尝试获取lock2
8.         Thread thread1 = new Thread(() -> {
9.             synchronized (lock1) {
10.                 System.out.println("线程1持有lock1，等待lock2...");
11.                 try {
12.                     Thread.sleep(10000); // 等个10秒增加死锁概率
13.                 } catch (InterruptedException e) {
14.                     e.printStackTrace();
15.                 }
16.                 synchronized (lock2) {
17.                     System.out.println("线程1成功获取lock2");
18.                 }
19.             }
20.         });
21.         // 线程2：先获取lock2，再尝试获取lock1
22.         Thread thread2 = new Thread(() -> {
23.             synchronized (lock2) {
24.                 System.out.println("线程2持有lock2，等待lock1...");
25.                 try {
26.                     Thread.sleep(10000); // 等个10秒增加死锁概率
27.                 } catch (InterruptedException e) {
28.                     e.printStackTrace();
29.                 }
30.                 synchronized (lock1) {
31.                     System.out.println("线程2成功获取lock1");
32.                 }
33.             }
34.         });
35.         
36.         thread1.start();
37.         thread2.start();
38.         try {
39.             thread1.join();
40.             thread2.join();
41.         } catch (InterruptedException e) {
42.             e.printStackTrace();
43.         }
44.         
45.         System.out.println("程序正常结束（这行永远不会执行）");
46.     }
47. }

复制代码

不使用Thread.sleep

可以使用 countDownLatch 来实现死锁，思路为:

• 新建一个count为2的 CountDownLatch 对象 latch。
  
• thread1 持有 lock1 后，调用 latch.countDown() 将计数减一，随后调用 latch.await() 等待，直到 thread2 也持有 lock2 后调用 latch.countDownd()
  
• thread2 持有 lock2 后，调用 latch.countDown()将计数减一，随后调用 latch.await() 直到 thread1 调用 latch.countDown()
  
• thread1 想要 lock2，但 thread2 持有了它
  
• thread2 想要 lock1，但 thread1 持有了它
  
• 由于互相等待对方释放锁，因此死锁发生
  

1. import java.util.concurrent.CountDownLatch;
3. public class GuaranteedDeadlock {
4.     private static final Object lock1 = new Object();
5.     private static final Object lock2 = new Object();
6.     private static final CountDownLatch latch = new CountDownLatch(2);
8.     public static void main(String[] args) {
9.         Thread thread1 = new Thread(() -> {
10.             synchronized (lock1) {
11.                 System.out.println("Thread 1: Holding lock1...");
12.                 latch.countDown(); // 让 thread2 也开始执行
13.                
14.                 try {
15.                         latch.await(); // 保证两个线程同时竞争
16.                 } catch (InterruptedException e) {
17.                         e.printStackTrace();
18.                 }
19.                 synchronized (lock2) {
20.                     System.out.println("Thread 1: Acquired lock2!");
21.                 }
22.             }
23.         });
25.         Thread thread2 = new Thread(() -> {
26.             synchronized (lock2) {
27.                 System.out.println("Thread 2: Holding lock2...");
28.                 latch.countDown(); // 让 thread1 也开始执行
29.                
30.                 try {
31.                         latch.await(); // 保证两个线程同时竞争
32.                 } catch (InterruptedException e) {
33.                         e.printStackTrace();
34.                     }
35.                    
36.                 synchronized (lock1) {
37.                     System.out.println("Thread 2: Acquired lock1!");
38.                 }
39.             }
40.         });
42.         thread1.start();
43.         thread2.start();
44.     }
45. }

复制代码

除此之外，也可以使用CycliBarrier
错误示范

1. public class DeadlockExample {
2.     private static final Object lock1 = new Object();
3.     private static final Object lock2 = new Object();
5.     public static void main(String[] args) {
6.         Thread thread1 = new Thread(() -> {
7.             synchronized (lock1) {
8.                 System.out.println("Thread 1: Holding lock1...");
9.                
10.                 // 试图获取 lock2
11.                 synchronized (lock2) {
12.                     System.out.println("Thread 1: Acquired lock2!");
13.                 }
14.             }
15.         });
17.         Thread thread2 = new Thread(() -> {
18.             synchronized (lock2) {
19.                 System.out.println("Thread 2: Holding lock2...");
20.                
21.                 // 试图获取 lock1（但 lock1 此时被 Thread1 持有）
22.                 synchronized (lock1) {
23.                     System.out.println("Thread 2: Acquired lock1!");
24.                 }
25.             }
26.         });
28.         thread1.start();
29.         thread2.start();
30.     }
31. }

复制代码

上述的代码无法保证死锁，因为Java 的线程调度是由操作系统决定的，线程的执行顺序是不可预测的，thread1 可能会在 thread2 运行前快速获取 lock1 和lock2，然后释放它们，从而避免死锁
所以这段代码死锁的发生概率不是 100%。这也是为什么第一种方式要使用Thread.sleep来保证两个线程都分别获得了锁

来源：新程序网络收集，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！