死锁定义
线程死锁描述的是这样一种情况：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。
由于线程被无限期地阻塞，因此程序不可能正常终止。如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，
它们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。
产生死锁的4个条件
- 互斥条件：该资源任意一个时刻只由一个线程占用。
- 请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺条件:线程已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
- 循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系。
如何预防死锁
破坏死锁产生的必要条件即可：
- 破坏请求与保持条件 ：一次性申请所有的资源。
- 破坏不剥夺条件 ：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
- 破坏循环等待条件 ：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。
模拟生成死锁
import java.util.concurrent.TimeUnit;
/**
* 死锁生成
*/
public class TestDeadLockCreate {
public static void main(String[] args) {
Object lock1 = new Object();
Object lock2 = new Object();
new Thread("ThreadA") {
@Override
public void run() {
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " acquire lock1");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " acquire lock2");
}
}
}
}.start();
new Thread("ThreadB") {
@Override
public void run() {
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " acquire lock2");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " acquire lock1");
}
}
}
}.start();
}
}
线程 ThreadA 通过 synchronized (lock1) 获得 lock1 的监视器锁，然后通过TimeUnit.SECONDS.sleep(1)，
让线程 ThreadA 休眠 1s 为的是让线程 ThreadB 得到执行然后获取到 lock2 的监视器锁。
线程 ThreadA 和线程 ThreadB 休眠结束后都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，
这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。
死锁检测
JConsole检测
JConsole 是一种基于JMX的可视化监视、管理工具，可以监控我们的程序。
程序检测
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* 死锁检测
*/
public class TestDeadLockDetector {
public static void main(String[] args) throws InterruptedException {
mockCreateDeadLockBySynchronized();
mockCreateDeadLockByReentrantLock();
//先休眠2秒确保死锁已经产生再检测
TimeUnit.SECONDS.sleep(2);
deadLockDetect();
}
/**
* 检测死锁
*/
private static void deadLockDetect() {
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
//获取monitor lock(synchronized)和owner lock(java.util.concurrent)
long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
//获取monitor lock(synchronized)
long[] monitorDeadlockedThreads = threadMXBean.findMonitorDeadlockedThreads();
if (deadlockedThreads != null) {
System.out.println("deadlockedThreads============");
ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(deadlockedThreads);
for (ThreadInfo threadInfo : threadInfos) {
System.out.println(threadInfo.getThreadName());
}
}
if (monitorDeadlockedThreads != null) {
System.out.println("monitorDeadlockedThreads============");
ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(monitorDeadlockedThreads);
for (ThreadInfo threadInfo : threadInfos) {
System.out.println(threadInfo.getThreadName());
}
}
}
/**
* 通过synchronized锁的方式生成死锁
*/
private static void mockCreateDeadLockBySynchronized() {
Object lock1 = new Object();
Object lock2 = new Object();
new Thread("Thread-test1") {
@Override
public void run() {
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " acquire lock1");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " acquire lock2");
}
}
}
}.start();
new Thread("Thread-test2") {
@Override
public void run() {
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " acquire lock2");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " acquire lock1");
}
}
}
}.start();
}
/**
* 通过ReentrantLock锁的方式生成死锁
*/
private static void mockCreateDeadLockByReentrantLock() {
ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
new Thread("Thread-test3") {
@Override
public void run() {
lock1.lock();
try {
System.out.println(Thread.currentThread().getName() + " acquire lock1");
TimeUnit.SECONDS.sleep(1);
lock2.lock();
try {
System.out.println(Thread.currentThread().getName() + " acquire lock2");
} finally {
lock2.unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock1.unlock();
}
}
}.start();
new Thread("Thread-test4") {
@Override
public void run() {
lock2.lock();
try {
System.out.println(Thread.currentThread().getName() + " acquire lock2");
TimeUnit.SECONDS.sleep(1);
lock1.lock();
try {
System.out.println(Thread.currentThread().getName() + " acquire lock1");
} finally {
lock1.unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock2.unlock();
}
}
}.start();
}
}
输出结果为
Thread-test1 acquire lock1
Thread-test3 acquire lock1
Thread-test2 acquire lock2
Thread-test4 acquire lock2
deadlockedThreads============
Thread-test1
Thread-test2
Thread-test3
Thread-test4
monitorDeadlockedThreads============
Thread-test1
Thread-test2
核心类为ThreadMXBean，JConsole内部也是使用它来检测的，有两个方法findDeadlockedThreads()和findDeadlockedThreads()，
findMonitorDeadlockedThreads()方法只能获取monitor lock(synchronized)，而findDeadlockedThreads()还可以获取owner lock(java.util.concurrent.AbstractOwnableSynchronizer)。