Java并发编程——死锁

原创于 2025-10-16 08:25:35 发布 · 893 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#java #死锁 #并发

Java并发编程专栏收录该内容

8 篇文章

订阅专栏

先看一段代码，代码来自Java并发编程的艺术

public class DeadLockDemo {
		privat static String A = "A";
		private static String B = "B";
		public static void main(String[] args) {
				new DeadLockDemo().deadLock();
		}
		private void deadLock() {
				Thread t1 = new Thread(new Runnable() {
					@Override
					publicvoid run() {
						synchronized (A) {
							try { Thread.currentThread().sleep(2000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							synchronized (B) {
								System.out.println("1");
							}
						}
					}
				});
				Thread t2 = new Thread(new Runnable() {
					@Override
					publicvoid run() {
						synchronized (B) {
							synchronized (A) {
								System.out.println("2");
							}
						}
					}
				});
				t1.start();
				t2.start();
		}
}

代码分析：为什么会引起死锁

这段代码是一个经典的Java多线程死锁（Deadlock）演示示例。死锁是指两个或更多线程无限期阻塞，互相等待对方释放资源，导致整个程序无法继续执行。代码中通过两个线程（t1 和 t2）对两个共享资源（字符串 A 和 B）的锁获取顺序不同，结合 t1 的 sleep 延迟，制造了循环等待的条件。下面我一步步拆解代码逻辑和执行过程（忽略代码中的拼写错误，如“privat”应为“private”，“publicvoid”应为“public void”，这些不影响核心行为）。

1. 代码核心结构

共享资源：两个静态字符串 A 和 B，作为锁对象（synchronized 块使用它们作为监视器）。

线程 t1：

synchronized (A) {  // 先获取 A 的锁
    try { Thread.sleep(2000); } catch (...) { ... }  // 睡 2 秒，模拟工作
    synchronized (B) {  // 然后尝试获取 B 的锁
        System.out.println("1");
    }
}

t1 的锁顺序：A → B。

线程 t2：

synchronized (B) {  // 先获取 B 的锁
    synchronized (A) {  // 然后尝试获取 A 的锁
        System.out.println("2");
    }
}

t2 的锁顺序：B → A。

启动：t1.start(); t2.start(); 几乎同时启动。

2. 死锁发生的执行过程

死锁满足四个必要条件（Coffman 条件）：互斥（锁独占）、持有并等待、不可抢占、循环等待。这里全满足。假设 t1 和 t2 同时启动（实际中线程调度不确定，但 sleep 确保了关键时序）：

初始阶段：两个线程开始执行。
- t1 快速获取 A 的锁（因为 A 未被占用），进入 synchronized (A) 块，然后执行 sleep(2000)，持有 A 锁睡 2 秒。
- t2 同时尝试获取 B 的锁（B 未被占用），成功获取 B 锁，进入 synchronized (B) 块，然后立即尝试获取 A 的锁。
关键冲突：
- t2 持有 B 锁，但 A 已被 t1 持有，无法获取 A（t1 还在睡）。t2 阻塞等待 A 锁释放。
- 2 秒后，t1 醒来，持有 A 锁，尝试获取 B 的锁，但 B 已被 t2 持有，无法获取 B。t1 阻塞等待 B 锁释放。
循环等待形成：
- t1：持有 A，等待 B。
- t2：持有 B，等待 A。
- 双方都不释放已持锁（synchronized 是互斥的，不可抢占），形成环路：t1 等 t2 释放 B，t2 等 t1 释放 A。程序卡死，无输出（或仅部分输出，取决于调度）。

3. 为什么必然死锁？

锁顺序不一致：t1 (A→B) 和 t2 (B→A) 违反了“锁排序原则”（建议统一顺序，如总按资源 ID 排序获取锁）。
时序依赖：sleep(2000) 确保 t1 先占 A，t2 先占 B。如果无 sleep，死锁概率降低（取决于 JVM 调度），但仍可能发生。
资源有限：A 和 B 是共享的，线程竞争加剧。

验证：运行代码，程序会挂起（无 “1” 或 “2” 输出），用 jstack 或 VisualVM 工具 dump 线程栈，会看到类似：

"Thread-0" #10 prio=5 os_prio=0 tid=0x... nid=0x... waiting for monitor entry [0x...]
   - waiting to lock <0x...> (a java.lang.String)  // B
   - locked <0x...> (a java.lang.String)  // A
"Thread-1" #11 prio=5 os_prio=0 tid=0x... nid=0x... waiting for monitor entry [0x...]
   - waiting to lock <0x...> (a java.lang.String)  // A
   - locked <0x...> (a java.lang.String)  // B