跳到主要内容
极客日志极客日志面向AI+效率的开发者社区
首页博客我的书AI学习GitHub 精选镜像AI 生图工具UI配色美学关于
搜索内容 / 工具 / 仓库 / 镜像...⌘K搜索
注册
博客列表
Javajava

Java 多线程死锁:产生原因与解决方案

探讨 Java 多线程死锁。分析死锁产生场景,包括单锁重入、双线程竞争及哲学家就餐模型。阐述死锁发生的四个必要条件:互斥、不可抢占、请求与保持、循环等待。提供两种解决方案:避免嵌套加锁及统一加锁顺序。可通过 JConsole 观察线程阻塞状态进行诊断。

RedisGeek发布于 2026/3/29更新于 2026/9/1082 浏览
Java 多线程死锁:产生原因与解决方案

死锁的产生

我们先从简单的死锁到复杂的问题展开讨论。

首先是一个线程、一把锁,因多次加锁而导致死锁问题。由于 Java 的 synchronized 实现了可重入锁,因此这个死锁问题不存在。这意味着当一个线程拥有一把锁时,可以对该锁进行多次加锁操作,而不会发生死锁问题,前文已详细讨论,此处不再赘述。

接下来是两个线程、两把锁的情况。当两个线程都想获得对方的锁时,就会发生死锁问题。代码如下:

public static void main(String[] args) {
    Object locker1 = new Object();
    Object locker2 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (locker1) {
            System.out.println("t1 线程获得了 锁 1");
            synchronized (locker2) {
                System.out.println("t1 线程成功获得了 锁 2");
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (locker2) {
            System.out.println("t2 线程获得了 锁 2");
            synchronized (locker1) {
                System.out.println("t2 线程成功获得了 锁 1");
            }
        }
    });
    t1.start();
    t2.start();
}

代码可能看似能成功执行,但这属于小概率情况。如果发生小概率事件,即死锁状态,程序就会一直卡住。

为什么会执行成功? t1.start() 的速度较快,可能直接获得了两把锁,t2 此时都还没开始执行就结束了。

小概率事件是指什么? 理论上,当 t1 和 t2 线程同时开始执行时,t1 会获得 locker1,t2 获得 locker2。由于 t1 还需要获得 locker2,t2 还需要获得 locker1,但都被对方先拿到了,此时这两个线程就无法继续执行下去,导致两个线程一直处于阻塞状态。

如何查看两个线程阻塞状态? 在 t1 线程加个 sleep,保证 t2 线程获得了 locker2。

public static void main(String[] args) { Object locker1 = new Object(); Object locker2 = new Object(); Thread t1 = new Thread(() -> { synchronized (locker1) { System.out.println("t1 线程获得了 锁 1"); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (locker2) { System.out.println("t1 线程成功获得了 锁 2"); } } }); Thread t2 = new Thread(() -> { synchronized (locker2) { System.out.println("t2 线程获得了 锁 2"); synchronized (locker1) { System.out.println("t2 线程成功获得了 锁 1"); } } }); t1.start(); t2.start(); }

使用 JConsole 工具查看,可以看到两个线程进入了 BLOCKED 状态(阻塞状态),并且能看到代码阻塞在第几行。此即为死锁现象。

对于多个线程和多把锁的情况,经典案例是哲学家就餐问题。

图中有 6 位哲学家,每位哲学家的左手和右手两边各有一根筷子。哲学家此时会有两个事件随机发生:拿起左手和右手的筷子吃面,或者思考哲学问题(不吃面)。

试想一个极端情况:如果每一个哲学家此时都想吃面,他们同时拿起左边的筷子,这时候没有一位哲学家拿到一双筷子,并且没有一位哲学家会放弃自己左手的筷子,都在等别人放下的筷子之后拿起来吃面,这时候谁都吃不成。

上面的哲学家可以类比我们的线程,筷子就是锁。虽然这种死锁发生的概率很低,但我们还是要防患于未然。

这种死锁是循环等待导致的,A 等待 B,B 等待 C,C 等待 A,构成一个回路。

死锁发生的原因

首先要回到锁的特性,因为锁是互斥的,一个线程拿到这个锁之后,另一个线程如果想要获得这个锁就必须阻塞等待。

锁是不可抢占的,不可剥夺的。一个线程拿到这个锁之后,除非这个线程解锁释放这个锁,否则其他线程是无法暴力抢占获取的。

请求和保持。这是发生在嵌套的情况下,也就是一个线程拿到锁 1 之后,在不释放锁 1 的前提下,申请获得锁 2,是有可能发生死锁的。换一种说法就是,一个线程在获取到锁 1 的时候,不想放弃这把锁 1,也就是在保持锁 1 的情况下,发出锁 2 的请求。

循环等待。多个线程,多把锁,在等待的过程中构成了循环,A 等待 B,B 也等待 A。

解决死锁的办法

首先回顾第一个和第二个产生死锁的原因,我们直到这个是锁的基本性质引出的,所以我们无力回天,除非你自己写一个锁的设置。

破除嵌套

那我们来看一下第三个问题怎么解决,只要我们避免不要嵌套加锁就可以了,也就是用完锁 1 然后释放掉,最后再申请锁 2 即可。

下面是死锁代码:

Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(() -> {
    synchronized (locker1) {
        System.out.println("t1 线程获得了 锁 1");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized (locker2) {
            System.out.println("t1 线程成功获得了 锁 2");
        }
    }
});
Thread t2 = new Thread(() -> {
    synchronized (locker2) {
        System.out.println("t2 线程获得了 锁 2");
        synchronized (locker1) {
            System.out.println("t2 线程成功获得了 锁 1");
        }
    }
});
t1.start();
t2.start();

下面的破除嵌套之后的代码:

public static void main(String[] args) {
    Object locker1 = new Object();
    Object locker2 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (locker1) {
            System.out.println("t1 线程获得了 锁 1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        synchronized (locker2) {
            System.out.println("t1 线程成功获得了 锁 2");
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (locker2) {
            System.out.println("t2 线程获得了 锁 2");
        }
        synchronized (locker1) {
            System.out.println("t2 线程成功获得了 锁 1");
        }
    });
    t1.start();
    t2.start();
}

运行正常,未发生死锁问题。

破除循环等待

我们可以实现约定好加锁的顺序,就可以破除循环等待了。

例如,我们约定每个线程加锁的时候永远都是获得序号小的锁,然后获得序号大的锁。

目录

  1. 死锁的产生
  2. 死锁发生的原因
  3. 解决死锁的办法
  4. 破除嵌套
  5. 破除循环等待

更多推荐文章

查看全部
  • Java+YOLO 推理延迟从 500ms 降至 20ms:JDK 26 虚拟线程与 Vector API 实战
  • Android 网络请求框架封装实战:基于 ViewModel + Retrofit + RxJava
  • GFPGAN 跨平台部署与人脸图像修复实战指南
  • 5 款 Stable Diffusion 云端协作平台推荐
  • OpenFPGA 完全指南:快速上手开源 FPGA IP 生成器
  • 基于 RAG 的生成式 AI:使用 LlamaIndex、Deep Lake 和 Pinecone 构建检索增强生成管道
  • Windows 下使用 WSL2 创建 Ubuntu 子系统并配置图形桌面
  • Python 处理 Excel 身份证号匹配的五种算法方案
  • 无线联邦学习:隐私保护下的分布式 AI 协同机制
  • Vivado 工程 Git 版本管理实战指南
  • 无人机路径规划算法
  • 蓝桥杯 C/C++ 组备考:C++ 基础知识(上)
  • 基于 SpringBoot 与 Vue 的校园组团平台信息管理系统设计
  • Canvas 与 Web Audio API 实现交互式烟花动画
  • OpenClaw 集成 GitHub Copilot GPT-5.4 故障修复指南
  • Ubuntu 20.04 安装 Ollama 及 Open WebUI 部署大型语言模型
  • Claude Code 与 GitHub Copilot CLI 终端效率深度评测
  • 零基础转行Python工程师的学习路径与经验分享
  • Python 实现中秋月相计算与月球数据可视化
  • KWDB 运维实战:用 SQL 打通 Metrics 与 CMDB 数据融合

相关免费在线工具

  • Keycode 信息

    查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具,Keycode 信息在线工具,online

  • Escape 与 Native 编解码

    JavaScript 字符串转义/反转义;Java 风格 \uXXXX(Native2Ascii)编码与解码。 在线工具,Escape 与 Native 编解码在线工具,online

  • JavaScript / HTML 格式化

    使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具,JavaScript / HTML 格式化在线工具,online

  • JavaScript 压缩与混淆

    Terser 压缩、变量名混淆,或 javascript-obfuscator 高强度混淆(体积会增大)。 在线工具,JavaScript 压缩与混淆在线工具,online

  • Base64 字符串编码/解码

    将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具,Base64 字符串编码/解码在线工具,online

  • Base64 文件转换器

    将字符串、文件或图像转换为其 Base64 表示形式。 在线工具,Base64 文件转换器在线工具,online