共计 6367 个字符，预计需要花费 16 分钟才能阅读完成。
前言
在本文中，咱们将探讨死锁的概念及其产生的起因，并通过示例代码来阐明死锁的呈现状况。咱们还将介绍如何通过毁坏死锁的不同条件来解决死锁问题，通过深刻理解死锁及其解决办法，咱们能够更好地应答并解决零碎中可能呈现的死锁状况。
1. 死锁的概念与产生死锁的条件
死锁指的是，一组相互竞争资源的线程，它们之间 互相期待 而导致 永恒阻塞 的景象。
当上面四个条件 同时满足 时，就会产生死锁:
1.
互斥：一个共享资源同一时间只能被一个线程占用；2.
占有且期待：线程 1 曾经取得共享资源 X，在期待获取共享资源 Y 的时候，它不会开释曾经占有的共享资源 X；3.
不可抢占：线程不能抢占其它线程曾经占有的共享资源；4.
循环期待：线程 1 期待线程 2 占有的资源，线程 2 期待线程 1 占有的资源，这就是循环期待。
2. 死锁示例及解决方案
呈现死锁时，只须要毁坏四个条件中的任意一个即可。然而，互斥条件是不能毁坏的，因为只有互斥能力解决线程平安问题，所以只须要毁坏其它三个条件中的任意一个即可。
2.1 死锁示例
以下代码模仿了两个人互相转账的场景。转账操作须要依照肯定的程序对账户进行加锁，以确保转账过程的安全性。然而，因为两个线程转账方向不同，导致加锁的程序也不同。最终，两个线程互相期待对方开释锁资源，导致呈现死锁景象。
账户类代码：
// 账户类
@Data
public class Account {
private String accountName; // 账户名
private int balance; // 账户余额
public Account(String accountName, int balance) {
this.accountName = accountName;
this.balance = balance;
}
// 转出操作，缩小转出方的余额
public void debit(int count) {this.balance -= count;}
// 转入操作，减少转入方的余额
public void credit(int count) {this.balance += count;}
}转账示例代码：
// 呈现死锁的示例
public class TransferAccount implements Runnable {
private Account formAccount; // 转出账户
private Account toAccount; // 转入账户
private int amount; // 转账金额
public TransferAccount(Account formAccount, Account toAccount, int amount) {
this.formAccount = formAccount;
this.toAccount = toAccount;
this.amount = amount;
}
@Override
public void run() {while(true) {
// 爱护转入转出账户，其余线程在转账期间无奈操作，保障线程平安
synchronized (formAccount) {synchronized (toAccount) {
// 转出方余额足够
if (formAccount.getBalance() >= amount) {formAccount.debit(amount);
toAccount.credit(amount);
}
}
}
System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
}
}
public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
Account lisi = new Account("李四", 2000);
// 因为上面持有锁的程序是相同的，所以可能会呈现持有并期待的状况而导致死锁
// 张三向李四转 10 块钱
Thread t1 = new Thread(new TransferAccount(zhangsan, lisi, 10));
// 李四向张三转 20 块钱
Thread t2 = new Thread(new TransferAccount(lisi, zhangsan, 20));
t1.start();
t2.start();}
}2.2 解决方案一：毁坏占有且期待条件
如果在进行操作之前，一次性获取所有的共享资源 ，那么就不会存在占有局部资源，期待另一部分资源开释的状况了， 毁坏 的是 占有且期待条件。这种形式相当于把锁的范畴扩充了，尽管能解决死锁问题，然而会导致性能升高。
咱们定义一个资源管理器，应用一个汇合对立治理共享资源来实现上述操作。资源管理器中定义一个互斥的资源申请办法，只有所有资源都没被占用的状况下，能力同时获取所有资源。
// 一次性获取资源的资源管理器，解决死锁的持有并期待问题
public class Allocator {private List<Object> list = new ArrayList<>(); // 通过汇合对立治理申请的资源
// 一次性申请所有资源
synchronized boolean apply(Object form, Object to) {
// 如果任意一个资源被占用了，就无奈一次性获取全副资源，返回 false
if (list.contains(form) || list.contains(to)) {return false;}
list.add(form);
list.add(to);
return true;
}
// 开释资源
synchronized void free(Object form, Object to) {list.remove(form);
list.remove(to);
}
}在转账操作中，先通过资源管理器获取资源，获取胜利的状况下才执行转账操作。转账操作执行结束后，开释资源。
// 通过 Allocator 对立申请资源
public class TransferAccount01 implements Runnable {
private Account formAccount; // 转出账户
private Account toAccount; // 转入账户
private int count; // 转入金额
private Allocator allocator; // 对立资源管理器
public TransferAccount01(Account formAccount, Account toAccount, int count, Allocator allocator) {
this.formAccount = formAccount;
this.toAccount = toAccount;
this.count = count;
this.allocator = allocator;
}
@Override
public void run() {while (true) {
// 一次性申请所有资源
if (allocator.apply(formAccount, toAccount)) {
try {if (formAccount.getBalance() >= count) {formAccount.debit(count);
toAccount.credit(count);
}
} finally {
// 开释资源
allocator.free(formAccount, toAccount);
}
}
System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
}
}
public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
Account lisi = new Account("李四", 2000);
Allocator allocator = new Allocator();
// 因为上面持有锁的程序是相同的，所以可能会呈现持有并期待的状况
// 张三向李四转 10 块钱
Thread t1 = new Thread(new TransferAccount01(zhangsan, lisi, 10, allocator));
// 李四向张三转 20 块钱
Thread t2 = new Thread(new TransferAccount01(lisi, zhangsan, 20, allocator));
t1.start();
t2.start();}
}2.3 解决方案二：毁坏不可抢占条件
在后面死锁的代码示例里，加锁形式用的是 synchronized，如果线程获取不到锁，就会始终阻塞在那里。咱们是否让线程在获取其它锁失败的状况下，被动开释本人持有的锁，从而解决死锁呢？
咱们能够通过非阻塞的 ReentrantLock 的 tryLock()办法获取锁，如果没有获取到锁，它会立刻返回，而不是阻塞线程。获取不到其它锁，那就调用 ReentrantLock 的 unlock()办法来开释本人持有的锁，从而 毁坏不可抢占条件。
// 毁坏不可抢占条件
public class TransferAccount02 implements Runnable {
private Account formAccount; // 转出账户
private Account toAccount; // 转入账户
private int count; // 转入金额
ReentrantLock formLock = new ReentrantLock();
ReentrantLock toLock = new ReentrantLock();
public TransferAccount02(Account formAccount, Account toAccount, int count) {
this.formAccount = formAccount;
this.toAccount = toAccount;
this.count = count;
}
@Override
public void run() {while(true) {
// 非阻塞期待，没有取得锁就不会进入上面这段代码
if (formLock.tryLock()) {
try {
// 假如获取了下面的锁，然而上面的锁没获取到
if (toLock.tryLock()) {
try {
// 转出方余额足够
if (formAccount.getBalance() >= count) {formAccount.debit(count);
toAccount.credit(count);
}
} finally {toLock.unlock(); // 开释 toLock 锁
}
}
} finally {formLock.unlock(); // 获取 toLock 失败时，开释持有的 formLock
}
}
System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
}
}
public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
Account lisi = new Account("李四", 2000);
// 张三向李四转 10 块钱
Thread t1 = new Thread(new TransferAccount02(zhangsan, lisi, 10));
// 李四向张三转 20 块钱
Thread t2 = new Thread(new TransferAccount02(lisi, zhangsan, 20));
t1.start();
t2.start();}
}2.4 解决方案三：毁坏循环期待条件
下面死锁案例中，导致死锁的根本原因是因为多线程加锁的程序不统一。如果张三和李四都遵循 雷同的加锁和解锁程序 ，就能够 毁坏循环期待条件 ，从而解决死锁问题。
在本实例中，按雷同的程序加锁解锁会毁坏原有的业务逻辑，这里仅仅是演示解决死锁的一种思路。在实在业务场景中，须要结合实际状况进行判断和取舍。
// 毁坏循环期待条件
public class TransferAccount03 implements Runnable {
private Account formAccount; // 转出账户
private Account toAccount; // 转入账户
private int count; // 转入金额
public TransferAccount03(Account formAccount, Account toAccount, int count) {
this.formAccount = formAccount;
this.toAccount = toAccount;
this.count = count;
}
@Override
public void run() {
// 不论内部调用程序如何，外部保障加锁程序统一
// 顺序调用的时候可能不走这段逻辑，然而逆序调用的时候会走这段逻辑，保障程序和逆序调用时候的加锁程序统一
Account left = null;
Account right = null;
if (formAccount.hashCode() > toAccount.hashCode()) {
left = toAccount;
right = formAccount;
}
while(true) {
// 爱护转入转出账户，其余线程在转账期间无奈操作
synchronized (left) {synchronized (right) {
// 转出方余额足够
if (formAccount.getBalance() >= count) {formAccount.debit(count);
toAccount.credit(count);
}
}
}
System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
}
}
public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
Account lisi = new Account("李四", 2000);
// 张三向李四转 10 块钱
Thread t1 = new Thread(new TransferAccount03(zhangsan, lisi, 10));
// 李四向张三转 20 块钱
Thread t2 = new Thread(new TransferAccount03(lisi, zhangsan, 20));
t1.start();
t2.start();}
}3. 总结
本文简略形容了死锁的概念、产生死锁须要满足的四个条件、毁坏死锁不同条件的思路和示例。在实战中如何预防死锁、排查死锁，将在前面的文章中补充。若文章中有形容不清或者有误的中央，欢送评论区探讨与斧正！
正文完
