理解JVM中的死锁:原因及解决方案

死锁是并发应用程序中的常见问题。在此类应用程序中,我们使用锁定机制来确保线程安全。此外,我们使用线程池和信号量来管理资源消耗。然而,在某些情况下,这些技术可能会导致死锁。

在本文中,我们将探讨死锁、死锁出现的原因以及如何分析和避免潜在的死锁情况。

理解死锁

简单地说, 当两个或多个线程在等待另一个线程持有的另一个资源可用时互相阻塞时就会发生死锁

JVM 并非为从死锁中恢复而设计的。因此,根据这些线程的操作,当发生死锁时,整个应用程序可能会停滞,或者会导致性能下降。

死锁示例

为了说明死锁现象,让我们创建一个在两个账户之间转移资金的模拟:

java 复制代码
private static void transferFunds(Account fromAccount, Account toAccount, BigDecimal amount) {
    synchronized (fromAccount) {
        System.out.println(Thread.currentThread().getName() + " acquired lock on " + fromAccount);
        synchronized (toAccount) {
            transfer(fromAccount, toAccount, amount);
        }
    }
}

public static void transfer(Account fromAccount, Account toAccount, BigDecimal amount) {
    if (fromAccount.getBalance().compareTo(amount) < 0)
        throw new RuntimeException("Insufficient funds.");
    else {
        fromAccount.withdraw(amount);
        toAccount.deposit(amount);
        System.out.println(Thread.currentThread()
                .getName() + " transferred $" + amount + " from " + fromAccount + " to " + toAccount);
    }
}

乍一看,上面的代码可能没有明显地表明 transferFunds() 方法如何导致死锁。似乎所有线程都以相同的顺序获取锁。但是,锁的顺序取决于传递给 transferFunds() 方法的参数的顺序。

在我们的例子中,当两个线程同时调用transferFunds() 方法时,可能会发生死锁,一个线程将资金从account1转移到account2,另一个线程将资金从account2转移到account1

java 复制代码
Thread thread1 = new Thread(() -> transferFunds(account1, account2, BigDecimal.valueOf(500)));
Thread thread2 = new Thread(() -> transferFunds(account2, account1, BigDecimal.valueOf(300)));

thread1.start();
thread2.start();

线程1获取**帐户 1 的锁并等待帐户 2 的锁,而线程 2持有**帐户 2 的锁并等待帐户 1的锁。

修复死锁

为了修复示例中的死锁, 我们可以定义锁的顺序,并在整个应用程序中一致地获取它们 。 这样,我们可以确保每个线程以相同的顺序获取锁。

引入对象排序的一种方法是利用它们的hashCode 值。此外, 我们还可以使用System.identityHashCode ,它返回 hashCode() 方法的值

让我们修改我们的transferFunds()方法并使用**System.identityHashCode引入锁排序:

java 复制代码
public static void transferFunds(final Account fromAccount, final Account toAccount, final BigDecimal amount) {
    int fromHash = System.identityHashCode(fromAccount);
    int toHash = System.identityHashCode(toAccount);

    if (fromHash < toHash) {
        synchronized (fromAccount) {
            System.out.println(Thread.currentThread().getName() + " acquired lock on " + fromAccount);
            synchronized (toAccount) {
                transfer(fromAccount, toAccount, amount);
            }
        }
    } else if (fromHash > toHash) {
        synchronized (toAccount) {
            System.out.println(Thread.currentThread().getName() + " acquired lock on " + toAccount);
            synchronized (fromAccount) {
                transfer(fromAccount, toAccount, amount);
            }
        }
    } else {
        synchronized (sameHashCodeLock) {
            synchronized (fromAccount) {
                System.out.println(Thread.currentThread().getName() + " acquired lock on " + fromAccount);
                synchronized (toAccount) {
                    transfer(fromAccount, toAccount, amount);
                }
            }
        }
    }
}

在上面的代码示例中,我们计算了fromAccounttoAccount的哈希码,并根据给定的值定义了锁顺序。

由于两个对象可以具有相同的哈希码,我们需要添加额外的逻辑并引入第三个sameHashCodeLock锁:

java 复制代码
private static final Object sameHashCodeLock = new Object();

在else 语句中,我们首先获取了sameHashCodeLock 上的锁,确保一次只有一个线程获取Account对象的锁。这消除了死锁的可能性。

避免死锁方法

进一步讨论如何避免死锁。我们应该记住,如果我们的程序一次只获取一个锁,它就永远不会遇到锁排序死锁。

指定锁定时间

我们的系统从死锁中恢复的一种方法是使用 定时锁定尝试 。我们可以使用Lock接口中的 tryLock() 方法。在该方法中,我们可以设置超时,如果方法无法获取锁,则超时后返回失败。这样,线程就不会无限期地阻塞:

java 复制代码
while (true) {
    if (fromAccount.lock.tryLock(1, SECONDS)) {
        System.out.println(Thread.currentThread().getName() + " acquired lock on " + fromAccount);
        try {
            if (toAccount.lock.tryLock(1, SECONDS)) {
                try {
                    transfer(fromAccount, toAccount, amount);
                } finally {
                    toAccount.lock.unlock();
                }
            }
        } finally {
            fromAccount.lock.unlock();
        }
    }

    SECONDS.sleep(10);
}

我们不应该忘记在finally块中调用 unlock() 方法。

使用线程转储检测死锁

最后,让我们看看如何使用线程转储fastThread工具检测死锁。线程转储包含每个正在运行的线程的堆栈跟踪和锁定信息。

导致死锁的生成的线程转储的一部分如下所示:

bash 复制代码
"Thread-0":
  waiting to lock monitor 0x000060000085c340 (object 0x000000070f994f08, a com.tier1app.deadlock.Account),
  which is held by "Thread-1"

"Thread-1":
  waiting to lock monitor 0x0000600000850410 (object 0x000000070f991c90, a com.tier1app.deadlock.Account),
  which is held by "Thread-0"

为了检查我们的应用程序是否遭遇死锁,我们可以将线程转储上传到fastThread工具中:

图:死锁问题突出显示快速线程工具

完整报告可在此处找到

接下来我们来看看导致此问题的详细信息:

图:发现的死锁详细信息快速线程工具

写在最后

在本文中,我们了解了什么是死锁,如何修复死锁以及如何避免死锁。

总而言之,当线程在等待从另一个线程获取的资源可用时相互阻塞时,并发应用程序中就会发生死锁。修复死锁的一种方法是使用对象的哈希码定义锁定顺序。

最后,我们可以使用线程转储和fastThread工具检测死锁。

本文翻译自

相关推荐
七星静香18 分钟前
laravel chunkById 分块查询 使用时的问题
java·前端·laravel
Jacob程序员19 分钟前
java导出word文件(手绘)
java·开发语言·word
ZHOUPUYU20 分钟前
IntelliJ IDEA超详细下载安装教程(附安装包)
java·ide·intellij-idea
stewie623 分钟前
在IDEA中使用Git
java·git
problc31 分钟前
Flutter中文字体设置指南:打造个性化的应用体验
android·javascript·flutter
Elaine20239138 分钟前
06 网络编程基础
java·网络
G丶AEOM40 分钟前
分布式——BASE理论
java·分布式·八股
落落鱼201340 分钟前
tp接口 入口文件 500 错误原因
java·开发语言
想要打 Acm 的小周同学呀41 分钟前
LRU缓存算法
java·算法·缓存
镰刀出海44 分钟前
Recyclerview缓存原理
java·开发语言·缓存·recyclerview·android面试