Java产生死锁的一个示例

liuliuliudedabuliu

于 2023-01-14 04:02:30 发布

阅读量266

点赞数

文章标签： java junit 开发语言

原文链接：https://blog.chean.cc/2023/01/14/%e6%ad%bb%e9%94%81%e7%9a%84%e4%b8%80%e4%b8%aa%e7%a4%ba%e4%be%8b/

版权

该文提供了一个Java代码示例，演示了死锁如何在多线程环境中发生。通过两个线程threadA和threadB，每个线程试图按照特定顺序获取两个共享资源A和B，从而形成资源间的循环等待，导致程序进入死锁状态。Maven项目依赖了JUnit进行测试，最终程序会卡在while循环中，无法继续执行，显示出死锁的发生。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

产生死锁的一个示例

死锁产生的条件：线程之间互相持有对方需要的资源，互相依赖且无法释放，形成回环。
以下是一个示例代码。
环境：maven项目，使用了junit（也可以使用main方法）
maven依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>concurrency_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

java示例代码：

package concurrency.demo;

import org.junit.Assert;
import org.junit.Test;
public class DeadLockDemo {
    private static String A = "A";
    private static String B = "B";

    private volatile boolean flag = false;

    /**
     * 测试产生死锁的代码。
     * 实现死锁：
     * 1、threadA依次需要A->B，中间sleep 一秒（确保持有资源）
     * 2、threadB依次需要B->A，中间sleep 一秒（确保持有资源）
     * threadA和threadB分别尝试将flag修改为true，如果flag最终为true，则有任意一个方法执行成功，否则失败（即产生了死锁）
     */
    @Test
    public void testGenDeadLock() throws InterruptedException {
        Thread threadA = new Thread(() -> {
            synchronized (A) {
                System.out.println(Thread.currentThread().getName() + "持有：" + A);
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (B) {
                    System.out.println(Thread.currentThread().getName() + "持有：" + B);
                    flag = true;
                }
            }
        });
        threadA.setName("threadA");

        Thread threadB = new Thread(() -> {
            synchronized (B) {
                System.out.println(Thread.currentThread().getName() + "持有：" + B);
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (A) {
                    System.out.println(Thread.currentThread().getName() + "持有：" + A);
                    flag = true;
                }
            }
        });
        threadB.setName("threadB");

        // 启动线程，模拟死锁产生
        threadA.start();
        threadB.start();

        // 将代码流程卡住，通过flag判断是否有方法执行完毕
        while (flag == false) {
            Thread.sleep(100L);
        }
        Assert.assertTrue(flag);
        System.out.println("END");
    }
}

最终结果：程序卡在while循环，无法运行到Assert.assertTrue(flag)语句。
控制台输出：

threadB持有：B
threadA持有：A
// 如果正常执行将会有
// threadB持有：A
// threadA持有：B
// END

表明死锁产生。