死锁的产生
我们先从简单的死锁到复杂的问题展开讨论。
首先是一个线程、一把锁，因多次加锁而导致死锁问题。由于 Java 的 synchronized 实现了可重入锁，因此这个死锁问题不存在。这意味着当一个线程拥有一把锁时，可以对该锁进行多次加锁操作，而不会发生死锁问题，前文已详细讨论，此处不再赘述。
接下来是两个线程、两把锁的情况。当两个线程都想获得对方的锁时，就会发生死锁问题。代码如下：
public static void main(String[] args) {
Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(() -> {
synchronized (locker1) {
System.out.println("t1 线程获得了 锁 1");
synchronized (locker2) {
System.out.println("t1 线程成功获得了 锁 2");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (locker2) {
System.out.println("t2 线程获得了 锁 2");
synchronized (locker1) {
System.out.println("t2 线程成功获得了 锁 1");
}
}
});
t1.start();
t2.start();
}
代码可能看似能成功执行，但这属于小概率情况。如果发生小概率事件，即死锁状态，程序就会一直卡住。
为什么会执行成功？ t1.start() 的速度较快，可能直接获得了两把锁，t2 此时都还没开始执行就结束了。
小概率事件是指什么？ 理论上，当 t1 和 t2 线程同时开始执行时，t1 会获得 locker1，t2 获得 locker2。由于 t1 还需要获得 locker2，t2 还需要获得 locker1，但都被对方先拿到了，此时这两个线程就无法继续执行下去，导致两个线程一直处于阻塞状态。
如何查看两个线程阻塞状态？ 在 t1 线程加个 sleep，保证 t2 线程获得了 locker2。
public static void main(String[] args) {
Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(() -> {
synchronized (locker1) {
System.out.println("t1 线程获得了 锁 1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2) {
System.out.println("t1 线程成功获得了 锁 2");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (locker2) {
System.out.println("t2 线程获得了 锁 2");
synchronized (locker1) {
System.out.println("t2 线程成功获得了 锁 1");
}
}
});
t1.start();
t2.start();
}
使用 JConsole 工具查看，可以看到两个线程进入了 BLOCKED 状态（阻塞状态），并且能看到代码阻塞在第几行。此即为死锁现象。
对于多个线程和多把锁的情况，经典案例是哲学家就餐问题。
图中有 6 位哲学家，每位哲学家的左手和右手两边各有一根筷子。哲学家此时会有两个事件随机发生：拿起左手和右手的筷子吃面，或者思考哲学问题（不吃面）。
试想一个极端情况：如果每一个哲学家此时都想吃面，他们同时拿起左边的筷子，这时候没有一位哲学家拿到一双筷子，并且没有一位哲学家会放弃自己左手的筷子，都在等别人放下的筷子之后拿起来吃面，这时候谁都吃不成。
上面的哲学家可以类比我们的线程，筷子就是锁。虽然这种死锁发生的概率很低，但我们还是要防患于未然。
这种死锁是循环等待导致的，A 等待 B，B 等待 C，C 等待 A，构成一个回路。
死锁发生的原因
首先要回到锁的特性，因为锁是互斥的，一个线程拿到这个锁之后，另一个线程如果想要获得这个锁就必须阻塞等待。
锁是不可抢占的，不可剥夺的。一个线程拿到这个锁之后，除非这个线程解锁释放这个锁，否则其他线程是无法暴力抢占获取的。
请求和保持。这是发生在嵌套的情况下，也就是一个线程拿到锁 1 之后，在不释放锁 1 的前提下，申请获得锁 2，是有可能发生死锁的。换一种说法就是，一个线程在获取到锁 1 的时候，不想放弃这把锁 1，也就是在保持锁 1 的情况下，发出锁 2 的请求。
循环等待。多个线程，多把锁，在等待的过程中构成了循环，A 等待 B，B 也等待 A。
解决死锁的办法
首先回顾第一个和第二个产生死锁的原因，我们直到这个是锁的基本性质引出的，所以我们无力回天，除非你自己写一个锁的设置。
破除嵌套
那我们来看一下第三个问题怎么解决，只要我们避免不要嵌套加锁就可以了，也就是用完锁 1 然后释放掉，最后再申请锁 2 即可。
下面是死锁代码：
Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(() -> {
synchronized (locker1) {
System.out.println("t1 线程获得了 锁 1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2) {
System.out.println("t1 线程成功获得了 锁 2");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (locker2) {
System.out.println("t2 线程获得了 锁 2");
synchronized (locker1) {
System.out.println("t2 线程成功获得了 锁 1");
}
}
});
t1.start();
t2.start();
下面的破除嵌套之后的代码：
public static void main(String[] args) {
Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(() -> {
synchronized (locker1) {
System.out.println("t1 线程获得了 锁 1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
synchronized (locker2) {
System.out.println("t1 线程成功获得了 锁 2");
}
});
Thread t2 = new Thread(() -> {
synchronized (locker2) {
System.out.println("t2 线程获得了 锁 2");
}
synchronized (locker1) {
System.out.println("t2 线程成功获得了 锁 1");
}
});
t1.start();
t2.start();
}
运行正常，未发生死锁问题。
破除循环等待
我们可以实现约定好加锁的顺序，就可以破除循环等待了。
例如，我们约定每个线程加锁的时候永远都是获得序号小的锁，然后获得序号大的锁。
