一文详解，死锁与解决方案（附源码）
死锁的现象
想象一个场景，账户A给账户B转账，同时账户B也给账户A转账，两个账户都需要锁住余额，所以通常会申请两把锁，转账时，先锁住自己的账户，并获取对方的锁，保证同一时刻只能有一个线程去执行转账。
这时可能就会出现，对方给我转账，同时我也给对方转账，那么双方都持有自己的锁，且尝试去获取对方的锁，这就造成可能一直申请不到对方的锁，循环等待，就会发生“死锁”。
一旦发生死锁，线程一直占用着资源无法释放，又无法完成转账，就会造成系统假死。
什么是死锁？
“死锁”就是两个或两个以上的线程在执行过程中，互相持有对方所需要的资源，导致这些线程处于等待状态，无法继续执行。若无外力作用，它们都将无法继续执行下去，就进入了“永久”阻塞的状态。
图1 死锁的现象
如图所示，线程1获取了资源1，同时去请求获取资源2，但是线程2已经占有资源2了，所以线程1只能等待。同样的，线程2占有了资源2，要请求获取资源1，但资源1已经被线程1占有了，只能等待。于是线程1和线程2都在等待持有对方的持有的资源，就会无限等待下去，这就是死锁现象。
模拟发生死锁的场景
下面写一段代码，模拟两个线程各自持有了锁，然后请求获取对方持有的锁，发生死锁的现象。
public class DeadLock {
public static String obj1 = "obj1";
public static String obj2 = "obj2";
public static void main(String[] args) {
Thread a = new Thread(new Lock1());
Thread b = new Thread(new Lock2());
a.start();
b.start();
}
static class Lock1 implements Runnable {
@Override
public void run() {
try {
System.out.println("Lock1 running");
synchronized (DeadLock.obj1) {
System.out.println("Lock1 lock obj1");
Thread.sleep(5000);
synchronized (DeadLock.obj2) {
System.out.println("Lock1 lock obj2");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
static class Lock2 implements Runnable {
@Override
public void run() {
try {
System.out.println("Lock2 running");
synchronized (DeadLock.obj2) {
System.out.println("Lock2 lock obj2");
Thread.sleep(5000);
synchronized (DeadLock.obj1) {
System.out.println("Lock2 lock obj1");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}程序启动后，从控制台输出，就能看出两个线程都没有结束，而是被卡住了。
图2 死锁demo输出
我们用jvisualVM看下线程的堆栈信息：
图3 jvisualVM堆栈信息
我们用jvisualVM查看线程的堆栈信息，发现已经检测到了死锁的存在，而且定位到了具体的代码行。
死锁产生的原因
死锁的发生也必须具备一定的条件，必须具备以下四个条件：
- 互斥，共享资源 X 和 Y 只能被一个线程占用；
- 占有且等待，线程01 已经取得共享资源 X，在等待共享资源 Y 的时候，不释放共享资源 X；
- 不可抢占，其他线程不能强行抢占线程01 占有的资源；
- 循环等待，线程01 等待线程02 占有的资源，线程02 等待线程01 占有的资源，就是循环等待。
如何避免死锁？
死锁一旦发生，并没有什么好的方法解决，通常我们只能避免死锁的发生。
怎么避免呢？那就要看针对死锁发生的原因去解决。
- 首先，“互斥”是没有办法避免的，你想从账户A转账到账户B，就必须加锁，就没法避免互斥的存在。
- 对于“占用且等待”这个条件，我们可以一次性申请所有的资源，这样就不存在等待了。
- 对于“不可抢占”这个条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以在一定时间后，主动释放它占有的资源，这样就解决了不可抢占这个条件。
- 对于“循环等待”，我们可以靠按“次序”申请资源来预防。所谓按序申请，就是给资源设定顺序，申请的时候可以先申请序号小的资源，再申请序号大的，这样资源线性化后，自然就不存在循环等待了。
所以，总结来看，避免死锁的发生有三种方法：破坏占用且等待的条件、破坏不可抢占条件、破坏循环等待条件。
1、破坏占用且等待条件
我们要破坏占用且等待，就是一次性申请占有所有的资源。账户A给账户B转账，就可以一次性申请账户A和账户B的锁，同时拿到两个锁之后，在执行转账操作。
public class DeadLock2 {
public static void main(String[] args) {
Account a = new Account();
Account b = new Account();
a.transfer(b, 100);
b.transfer(a, 200);
}
static class Allocator {
private List<Account> als = new ArrayList<>();
private void Allocator() {
}
synchronized boolean apply(Account from, Account to) {
if (als.contains(from) || als.contains(to)) {
return false;
} else {
als.add(from);
als.add(to);
}
return true;
}
synchronized void clean(Account from, Account to) {
als.remove(from);
als.remove(to);
}
}
static class Account {
private Allocator actr = DeadLock2.getInstance();
private int balance;
void transfer(Account target, int amt) {
while (!actr.apply(this, target)){
}
try {
synchronized (this) {
System.out.println(this.toString() + " lock lock1");
synchronized (target) {
System.out.println(this.toString() + " lock lock2");
if (this.balance > amt) {
this.balance -= amt;
target.balance += amt;
}
}
}
} finally {
actr.clean(this, target);
}
}
}
private static class SingleTonHoler {
private static Allocator INSTANCE = new Allocator();
}
public static Allocator getInstance() {
return SingleTonHoler.INSTANCE;
}
}输出结果如下：
图4 破坏占用且等待条件输出
从输出结果看出，并没有发生死锁，一个账户先获取了两把锁，完成转账后，另一个账号再获取到两把锁，完成转账。
上面的demo比较见到，如果账号没获取到锁，会一直while循环等待，可以优化为notify/wait的方式。
2、 破坏不可抢占条件
破坏不抢占条件，需要发生死锁的线程能够主动释放它占有的资源，但使用synchronized是做不到的。原因为synchronized申请不到资源时，线程直接进入了阻塞状态，而线程进入了阻塞状态也就没有办法释放它占有的资源了。
不过JDK中的Lock解决这个问题。
使用Lock类中的定时tryLock获取锁，可以指定一个超时时限（Timeout），在等待超过该时间后tryLock就会返回一个失败信息，也会释放其拥有的资源。
public class DeadLock3 {
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
public static void main(String[] args) {
Thread a = new Thread(new Lock1());
Thread b = new Thread(new Lock2());
a.start();
b.start();
}
static class Lock1 implements Runnable {
@Override
public void run() {
try {
System.out.println("Lock1 running");
while (true) {
if (lock1.tryLock(1, TimeUnit.MILLISECONDS)) {
System.out.println("Lock1 get lock1");
if (lock2.tryLock(1, TimeUnit.MILLISECONDS)) {
System.out.println("Lock·get lock2");
return;
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock1.unlock();
lock2.unlock();
}
}
}
static class Lock2 implements Runnable {
@Override
public void run() {
try {
System.out.println("Lock2 running");
while (true) {
if (lock1.tryLock(1, TimeUnit.MILLISECONDS)) {
System.out.println("Lock2 get lock1");
if (lock2.tryLock(1, TimeUnit.MILLISECONDS)) {
System.out.println("Lock2 get lock2");
return;
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock1.unlock();
lock2.unlock();
}
}
}
}输出结果如下：
图5 破坏不可抢占条件输出
从输出结果看出，并没有发生死锁，一个账户先尝试获取两把锁，如果超时没有获取到，就会下次重试再去获取，直到获取成功。
3、破坏循环等待条件
破坏循环等待，就是要对系统中的资源进行统一编号，进程必须按照资源的编号顺序提出。这样做就能保证系统不出现死锁。这就是“资源有序分配法”。代码如下：
class Account {
private int id;
private int balance;
void transfer(Account target, int amt){
Account left = this;
Account right = target;
if (this.id > target.id) {
left = target;
right = this;
}
synchronized(left){
synchronized(right){
if (this.balance > amt){
this.balance -= amt;
target.balance += amt;
}
}
}
}
}总结：
文章主要讲了死锁发生的原因以及解决方法，但我们平时写的代码，可能逻辑比这里的例子要复杂很多，如果产生了死锁，可能会比较难以定位到，所以我们平时写代码时，尽量不要把多个锁交织在一起。