本文深入探讨了Java同步方法中因锁获取顺序不一致导致的死锁问题。通过引入一致的锁获取顺序机制，并结合java.util.concurrent.locks.Lock接口的灵活运用，提供了有效的死锁预防策略。文章详细阐述了如何基于对象唯一标识符来确定锁的获取顺序，并强调了在多线程环境中维护资源访问一致性的重要性。
理解同步方法中的死锁风险
在java并发编程中，synchronized关键字是实现线程同步的常用机制，它确保同一时刻只有一个线程可以执行特定的代码块或方法。然而，不当的同步策略可能导致死锁，即两个或多个线程无限期地等待彼此释放资源。
一个经典的死锁场景发生在多个线程尝试获取多个锁，但获取顺序不一致时。考虑一个transferMoney方法，它需要同步两个Account对象以执行转账操作：
public class Account { private UUID id; private float balance; // 构造函数、getter/setter等 public UUID getId() { return id; } public void debit(float amount) { this.balance -= amount; } public void credit(float amount) { this.balance += amount; }}public class TransferService { public void transferMoney(Account a, Account b, float value) { synchronized(a) { // 线程1获取了A的锁 synchronized(b) { // 线程1尝试获取B的锁 // 执行转账逻辑 a.debit(value); b.credit(value); } } }}
假设现在有两个线程同时调用transferMoney方法：
线程1调用transferMoney(accountA, accountB, 100)线程2调用transferMoney(accountB, accountA, 50)
如果线程1成功获取了accountA的锁，并紧接着线程2成功获取了accountB的锁，那么：
线程1会等待accountB的锁（已被线程2持有）线程2会等待accountA的锁（已被线程1持有）
这将导致典型的死锁，两个线程都无法继续执行。
立即学习“Java免费学习笔记（深入）”；
策略一：强制一致的锁获取顺序
避免死锁的关键在于确保所有线程以相同的、预定义的顺序获取多个锁。这意味着我们不能依赖于方法参数的传入顺序，而应该基于锁对象的某个固有属性来确定其获取顺序。
为了实现这一点，我们可以为每个Account对象引入一个唯一标识符（例如UUID或Long ID），并约定在获取锁时，总是先获取ID较小的账户的锁，再获取ID较大的账户的锁。
首先，修改Account类，使其包含一个用于比较的唯一ID：
import java.util.Comparator;import java.util.UUID;import java.util.function.BinaryOperator;public class Account { private UUID id; private float balance; public Account(UUID id, float initialBalance) { this.id = id; this.balance = initialBalance; } public UUID getId() { return id; } public void debit(float amount) { if (this.balance < amount) { throw new IllegalArgumentException("Insufficient funds."); } this.balance -= amount; } public void credit(float amount) { this.balance += amount; } public float getBalance() { return balance; } @Override public String toString() { return "Account{" + "id=" + id.toString().substring(0, 8) + ", balance=" + balance + '}'; } // 辅助方法，用于确定两个账户中ID较小的那个 public static final BinaryOperator FIRST = BinaryOperator.minBy(Comparator.comparing(Account::getId)); // 辅助方法，用于确定两个账户中ID较大的那个 public static final BinaryOperator SECOND = BinaryOperator.maxBy(Comparator.comparing(Account::getId));}
接下来，修改transferMoney方法，使用FIRST和SECOND辅助方法来确定锁的获取顺序：
法语写作助手
法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。
31 查看详情
public class TransferService { public void transferMoney(Account a, Account b, float value) { // 确保不能向同一个账户转账 if (a.getId().equals(b.getId())) { throw new IllegalArgumentException("Cannot transfer money to the same account."); } // 确定锁的获取顺序：总是先获取ID较小的账户的锁，再获取ID较大的账户的锁 Account firstLock = Account.FIRST.apply(a, b); Account secondLock = Account.SECOND.apply(a, b); synchronized (firstLock) { synchronized (secondLock) { // 执行转账逻辑 System.out.println(Thread.currentThread().getName() + " acquired locks for " + firstLock.getId().toString().substring(0, 8) + " and " + secondLock.getId().toString().substring(0, 8)); try { // 模拟转账耗时 Thread.sleep(100); firstLock.debit(value); secondLock.credit(value); System.out.println(Thread.currentThread().getName() + " transferred " + value + " from " + a.getId().toString().substring(0, 8) + " to " + b.getId().toString().substring(0, 8)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } }}
通过这种方式，无论transferMoney方法被调用时accountA和accountB的传入顺序如何，firstLock和secondLock变量总是会引用到具有一致ID顺序的账户。例如，如果accountA.id小于accountB.id，那么firstLock总是accountA，secondLock总是accountB。这样，所有线程都会以synchronized(account_with_smaller_id) { synchronized(account_with_larger_id) {…} }的顺序获取锁，从而有效避免死锁。
策略二：使用java.util.concurrent.locks.Lock
除了synchronized关键字，Java并发API还提供了java.util.concurrent.locks.Lock接口，它提供了更灵活的锁机制。Lock接口的实现（如ReentrantLock）允许更精细地控制锁的获取和释放，尤其是在处理死锁时提供了额外的工具。
Lock接口的核心思想是，当一个线程需要获取多个锁时，如果它无法一次性获取所有必需的锁，就应该释放已经持有的锁，并稍后重试。这可以通过tryLock()方法实现，它尝试获取锁而不阻塞，并返回一个布尔值指示是否成功获取。
使用Lock的基本模式如下：
import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;// 假设每个Account对象内部有一个ReentrantLockpublic class AccountWithLock { private UUID id; private float balance; private final Lock lock = new ReentrantLock(); // 每个账户一个独立的锁 // ... 构造函数、getter/setter等 public Lock getLock() { return lock; }}public class TransferServiceWithLock { public void transferMoney(AccountWithLock a, AccountWithLock b, float value) { // 同样，先确定一致的锁获取顺序 AccountWithLock first = AccountWithLock.FIRST.apply(a, b); // 假设AccountWithLock也有FIRST/SECOND AccountWithLock second = AccountWithLock.SECOND.apply(a, b); Lock lock1 = first.getLock(); Lock lock2 = second.getLock(); boolean acquired1 = false; boolean acquired2 = false; try { // 尝试获取第一个锁 acquired1 = lock1.tryLock(); if (acquired1) { // 尝试获取第二个锁 acquired2 = lock2.tryLock(); if (acquired2) { // 成功获取所有锁，执行转账 a.debit(value); b.credit(value); } else { // 未能获取第二个锁，释放第一个锁，稍后重试 lock1.unlock(); } } } finally { // 确保所有获取的锁都被释放 if (acquired2) { lock2.unlock(); } if (acquired1) { // 再次检查，因为如果acquired2失败，acquired1可能仍为true lock1.unlock(); } } }}
注意事项：
tryLock()方法可以带超时参数，避免无限等待。finally块对于确保锁的释放至关重要，即使在转账过程中发生异常。使用Lock接口时，同样需要遵循一致的锁获取顺序原则，以简化死锁处理逻辑。
总结与最佳实践
死锁是并发编程中的一个常见陷阱，但通过遵循一些基本原则可以有效避免。
统一锁获取顺序： 这是预防多资源死锁最核心的策略。通过对需要同步的资源进行排序（例如，基于对象的唯一ID），并强制所有线程按照该顺序获取锁，可以消除循环等待的条件。避免嵌套锁： 尽量减少在持有锁的情况下再去获取另一个锁的情况。如果必须嵌套，务必确保锁的获取顺序是严格一致的。使用java.util.concurrent.locks.Lock： 对于更复杂的并发场景，ReentrantLock等Lock实现提供了比synchronized更强大的功能，如可中断的锁获取（lockInterruptibly()）、非阻塞的锁获取（tryLock()）以及公平性选项。这些特性可以帮助开发者构建更健壮的死锁恢复机制。设置锁超时： 在使用Lock时，tryLock(long timeout, TimeUnit unit)方法允许线程在指定时间内尝试获取锁。如果超时仍未获取，线程可以选择放弃并回退，而不是无限期等待。
通过深入理解死锁的成因并采纳上述策略，开发者可以显著提高并发应用程序的稳定性和可靠性。
以上就是Java并发：同步方法死锁预防策略的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/328630.html
微信扫一扫 
支付宝扫一扫 
