java死锁其实就是多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止，在开发中，我们遇到java死锁肯定要第一时间去分析原因并解决问题，那java死锁的原因及解决方法是什么?下面来我们就来给大家讲解一下。
java死锁的原因：
1、系统资源的竞争通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在 运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争 才可能产生死锁，对可剥夺资源的竞争是不会引起死锁的。
2、进程推进顺序非法进程在运行过程中，请求和释放资源的顺序不当，也同样会导致死锁。例如，并发进程 P1、P2分别保持了资源R1、R2，而进程P1申请资源R2，进程P2申请资源R1时，两者都 会因为所需资源被占用而阻塞。
3、信号量使用不当也会造成死锁。进程间彼此相互等待对方发来的消息，结果也会使得这 些进程间无法继续向前推进。例如，进程A等待进程B发的消息，进程B又在等待进程A 发的消息，可以看出进程A和B不是因为竞争同一资源，而是在等待对方的资源导致死锁。
4、死锁产生的必要条件
产生死锁必须同时满足以下四个条件，只要其中任一条件不成立，死锁就不会发生。
(1)互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用;
(2)不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
(3)请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
(4)循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
解决死锁问题的方法是：一种是用synchronized，一种是用Lock显式锁实现。
而如果不恰当的使用了锁，且出现同时要锁多个对象时，会出现死锁情况，如下：
LockTest.java 文件
import java.util.Date;
public class LockTest
{
public static String obj1 = "obj1";
public static String obj2 = "obj2";
public static void main(String[] args)
{
LockA la = new LockA();
new Thread(la)
.start();
LockB lb = new LockB();
new Thread(lb)
.start();
}
}
class LockA implements Runnable
{
public void run()
{
try
{
System.out.println(new Date()
.toString() + " LockA 开始执行");
while (true)
{
synchronized(LockTest.obj1)
{
System.out.println(new Date()
.toString() + " LockA 锁住 obj1");
Thread.sleep(3000); // 此处等待是给B能锁住机会
synchronized(LockTest.obj2)
{
System.out.println(new Date()
.toString() + " LockA 锁住 obj2");
Thread.sleep(60 * 1000); // 为测试，占用了就不放
}
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
class LockB implements Runnable
{
public void run()
{
try
{
System.out.println(new Date()
.toString() + " LockB 开始执行");
while (true)
{
synchronized(LockTest.obj2)
{
System.out.println(new Date()
.toString() + " LockB 锁住 obj2");
Thread.sleep(3000); // 此处等待是给A能锁住机会
synchronized(LockTest.obj1)
{
System.out.println(new Date()
.toString() + " LockB 锁住 obj1");
Thread.sleep(60 * 1000); // 为测试，占用了就不放
}
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}以上代码运行输出结果为：
Tue May 05 10: 51: 06 CST 2015 LockB 开始执行 Tue May 05 10: 51: 06 CST 2015 LockA 开始执行 Tue May 05 10: 51: 06 CST 2015 LockB 锁住 obj2 Tue May 05 10: 51: 06 CST 2015 LockA 锁住 obj1
此时死锁产生。
为了解决这个问题，我们不使用显示的去锁，我们用信号量去控制。
信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。
对于无法成功获取的情况，一般就是重复尝试，或指定尝试的次数，也可以马上退出。
来看下如下代码：
UnLockTest.java 文件
import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class UnLockTest
{
public static String obj1 = "obj1";
public static final Semaphore a1 = new Semaphore(1);
public static String obj2 = "obj2";
public static final Semaphore a2 = new Semaphore(1);
public static void main(String[] args)
{
LockAa la = new LockAa();
new Thread(la)
.start();
LockBb lb = new LockBb();
new Thread(lb)
.start();
}
}
class LockAa implements Runnable
{
public void run()
{
try
{
System.out.println(new Date()
.toString() + " LockA 开始执行");
while (true)
{
if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS))
{
System.out.println(new Date()
.toString() + " LockA 锁住 obj1");
if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS))
{
System.out.println(new Date()
.toString() + " LockA 锁住 obj2");
Thread.sleep(60 * 1000); // do something
}
else
{
System.out.println(new Date()
.toString() + "LockA 锁 obj2 失败");
}
}
else
{
System.out.println(new Date()
.toString() + "LockA 锁 obj1 失败");
}
UnLockTest.a1.release(); // 释放
UnLockTest.a2.release();
Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
class LockBb implements Runnable
{
public void run()
{
try
{
System.out.println(new Date()
.toString() + " LockB 开始执行");
while (true)
{
if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS))
{
System.out.println(new Date()
.toString() + " LockB 锁住 obj2");
if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS))
{
System.out.println(new Date()
.toString() + " LockB 锁住 obj1");
Thread.sleep(60 * 1000); // do something
}
else
{
System.out.println(new Date()
.toString() + "LockB 锁 obj1 失败");
}
}
else
{
System.out.println(new Date()
.toString() + "LockB 锁 obj2 失败");
}
UnLockTest.a1.release(); // 释放
UnLockTest.a2.release();
Thread.sleep(10 * 1000); // 这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}以上实例代码输出结构为：
Tue May 05 10: 59: 13 CST 2015 LockA 开始执行 Tue May 05 10: 59: 13 CST 2015 LockB 开始执行 Tue May 05 10: 59: 13 CST 2015 LockB 锁住 obj2 Tue May 05 10: 59: 13 CST 2015 LockA 锁住 obj1 Tue May 05 10: 59: 14 CST 2015 LockB 锁 obj1 失败 Tue May 05 10: 59: 14 CST 2015 LockA 锁 obj2 失败 Tue May 05 10: 59: 15 CST 2015 LockA 锁住 obj1 Tue May 05 10: 59: 15 CST 2015 LockA 锁住 obj2
Java死锁的解决方法主要是用synchronized以及Lock显式锁实现，另外大家要主意产生java死锁的4个条件，如果打破任何一个条件，就可让死锁消失。最后大家如果想要了解更多java常见问答知识，敬请关注奇Q工具网。
推荐阅读：