java中死锁最简单的情况是，一个线程t1持有锁l1并且申请获得锁l2，而另一个线程t2持有锁l2并且申请获得锁l1，因为默认的锁申请操作都是阻塞的，所以线程t1和t2永远被阻塞了。导致了死锁。这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程t1持有锁l1并且申请获得锁l2，而线程t2持有锁l2并且申请获得锁l3，而线程t3持有锁l3并且申请获得锁l1，这样导致了一个锁依赖的环路：t1依赖t2的锁l2，t2依赖t3的锁l3，而t3依赖t1的锁l1。从而导致了死锁。
从这两个例子，我们可以得出结论，产生死锁可能性的最根本原因是：线程在获得一个锁l1的情况下再去申请另外一个锁l2，也就是锁l1想要包含了锁l2，也就是说在获得了锁l1，并且没有释放锁l1的情况下，又去申请获得锁l2，这个是产生死锁的最根本原因。另一个原因是默认的锁申请操作是阻塞的。
2. java中如何避免死锁
既然我们知道了产生死锁可能性的原因，那么就可以在编码时进行规避。java是面向对象的编程语言，程序的最小单元是对象，对象封装了数据和操作，所以java中的锁一般也是以对象为单位的，对象的内置锁保护对象中的数据的并发访问。所以如果我们能够避免在对象的同步方法中调用其它对象的同步方法，那么就可以避免死锁产生的可能性。如下所示的代码，就存在死锁的可能性：
|
1
2
3
4
5
6
7
8
9
|
public class classb {
private string address;
// ...
public synchronized void method1(){
// do something
}
// ... ...
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class classa {
private int id;
private string name;
private classb b;
// ...
public synchronized void m1(){
// do something
b.method1();
}
// ... ...
}
|
上面的classa.m1()方法，在对象的同步方法中又调用了classb的同步方法method1()，所以存在死锁发生的可能性。我们可以修改如下，避免死锁：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class classa {
private int id;
private string name;
private classb b;
// ...
public void m2(){
synchronized(this){
// do something
}
b.method1();
}
// ... ...
}
|
这样的话减小了锁定的范围，两个锁的申请就没有发生交叉，避免了死锁的可能性，这是最理性的情况，因为锁没有发生交叉。但是有时是不允许我们这样做的。此时，如果只有classa中只有一个m1这样的方法，需要同时获得两个对象上的锁，并且不会将实例属性 b 溢出(return b;)，而是将实例属性 b 封闭在对象中，那么也不会发生死锁。因为无法形成死锁的闭环。但是如果classa中有多个方法需要同时获得两个对象上的锁，那么这些方法就必须以相同的顺序获得锁。
比如银行转账的场景下，我们必须同时获得两个账户上的锁，才能进行操作，两个锁的申请必须发生交叉。这时我们也可以打破死锁的那个闭环，在涉及到要同时申请两个锁的方法中，总是以相同的顺序来申请锁，比如总是先申请 id 大的账户上的锁 ，然后再申请 id 小的账户上的锁，这样就无法形成导致死锁的那个闭环。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class account {
private int id; // 主键
private string name;
private double balance;
public void transfer(account from, account to, double money){
if(from.getid() > to.getid()){
synchronized(from){
synchronized(to){
// transfer
}
}
}else{
synchronized(to){
synchronized(from){
// transfer
}
}
}
}
public int getid() {
return id;
}
}
|
这样的话，即使发生了两个账户比如 id=1的和id=100的两个账户相互转账，因为不管是哪个线程先获得了id=100上的锁，另外一个线程都不会去获得id=1上的锁(因为他没有获得id=100上的锁)，只能是哪个线程先获得id=100上的锁，哪个线程就先进行转账。这里除了使用id之外，如果没有类似id这样的属性可以比较，那么也可以使用对象的hashcode()的值来进行比较。
上面我们说到，死锁的另一个原因是默认的锁申请操作是阻塞的，所以如果我们不使用默认阻塞的锁，也是可以避免死锁的。我们可以使用reentrantlock.trylock()方法，在一个循环中，如果trylock()返回失败，那么就释放以及获得的锁，并睡眠一小段时间。这样就打破了死锁的闭环。
比如：线程t1持有锁l1并且申请获得锁l2，而线程t2持有锁l2并且申请获得锁l3，而线程t3持有锁l3并且申请获得锁l1
此时如果t3申请锁l1失败，那么t3释放锁l3，并进行睡眠，那么t2就可以获得l3了，然后t2执行完之后释放l2, l3，所以t1也可以获得l2了执行完然后释放锁l1, l2，然后t3睡眠醒来，也可以获得l1, l3了。打破了死锁的闭环。
这些情况，都还是比较好处理的，因为它们都是相关的，我们很容易意识到这里有发生死锁的可能性，从而可以加以防备。很多情况的场景都不会很明显的让我们察觉到会存在发生死锁的可能性。所以我们还是要注意：
一旦我们在一个同步方法中，或者说在一个锁的保护的范围中，调用了其它对象的方法时，就要十而分的小心：
1）如果其它对象的这个方法会消耗比较长的时间，那么就会导致锁被我们持有了很长的时间；
2）如果其它对象的这个方法是一个同步方法，那么就要注意避免发生死锁的可能性了；
最好是能够避免在一个同步方法中调用其它对象的延时方法和同步方法。如果不能避免，就要采取上面说到的编码技巧，打破死锁的闭环，防止死锁的发生。同时我们还可以尽量使用“不可变对象”来避免锁的使用，在某些情况下还可以避免对象的共享，比如 new 一个新的对象代替共享的对象，因为锁一般是对象上的，对象不相同了，也就可以避免死锁，另外尽量避免使用静态同步方法，因为静态同步相当于全局锁。还有一些封闭技术可以使用：比如堆栈封闭，线程封闭，threadlocal，这些技术可以减少对象的共享，也就减少了死锁的可能性。
总结一下：
死锁的根本原因
1）是多个线程涉及到多个锁，这些锁存在着交叉，所以可能会导致了一个锁依赖的闭环；
2）默认的锁申请操作是阻塞的。
所以要避免死锁，就要在一遇到多个对象锁交叉的情况，就要仔细审查这几个对象的类中的所有方法，是否存在着导致锁依赖的环路的可能性。要采取各种方法来杜绝这种可能性。
以上所述是小编给大家介绍的java中产生死锁的原因及如何避免详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
原文链接：https://blog.csdn.net/m0_38126177/article/details/78587845