1.什么是死锁
死锁是多线程或多进程并发编程中的一种常见问题,它发生在两个或多个线程(或进程)相互等待对方释放资源的情况下,导致它们都无法继续执行下去的状态。这种情况下,每个线程都在等待某个资源,而同时也拥有一些资源,这使得它们之间产生了僵局,无法继续执行。
死锁通常包括以下四个必要条件:
-
互斥条件(Mutual Exclusion):每个资源只能同时被一个线程占用。如果一个线程占用了某个资源,其他线程就无法同时占用它。
-
请求与保持条件(Hold and Wait):线程在持有某些资源的同时,又请求其他资源。如果线程在等待其他资源时不释放已占用的资源,就可能导致死锁。
-
不可剥夺条件(No Preemption):系统不能抢占线程占用的资源,只能由线程自愿释放。
-
循环等待条件(Circular Wait):多个线程之间形成一个环形等待其他线程释放资源的情况。
为了预防和解决死锁问题,可以采取以下策略:
-
加强互斥条件:尽量减少共享资源的互斥性,或者使用更高级的同步机制来替代基本的互斥锁。
-
加强请求与保持条件:要求数资源时,尽量一次性请求所有需要的资源,而不是逐个请求。
-
加强不可剥夺条件:允许操作系统抢占线程占用的资源,以避免某些线程长时间占用资源而导致死锁。
-
加强循环等待条件:引入资源分配图,检测潜在的死锁情况,然后采取措施来打破等待环路。
-
使用超时:线程在等待资源时,设置一个超时时间,超时后可以放弃等待或者重试。
-
使用死锁检测和恢复机制:系统可以定期检测死锁,并采取措施来解除死锁,如终止某些线程或回滚操作。
预防和解决死锁是多线程编程中的一个关键问题,需要综合考虑应用程序的需求和性能,以及选择适当的策略和工具来处理死锁情况。
2.手写一个死锁
在这个例子中,首先定义一个资源类,并实例化两个资源对象,然后使用线程池运行两个线程,线程1获取资源1后,睡眠2s后尝试获取资源2,线程2获取资源2后,睡眠2s后尝试获取资源1,由此满足死锁发生的四个必要条件,产生死锁现象。
public class LockDead {
public static void main(String[] args) {
//实例化两个资源对象
Resource resource1 = new Resource();
Resource resource2 = new Resource();
//定义一个线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
5,
1L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(5),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
//开启线程1
threadPoolExecutor.execute(()->{
synchronized (resource1){//线程1获取资源1后,进入睡眠状态
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前线程:"+Thread.currentThread().getName()+"获取资源"+"resource1");
System.out.println("当前线程:"+Thread.currentThread().getName()+"尝试获取资源resource2......");
synchronized (resource2){//线程1尝试获取资源2
System.out.println("当前线程:"+Thread.currentThread().getName()+"获取资源"+"resource2");
}
}
});
//开启线程2
threadPoolExecutor.execute(()->{
synchronized (resource2){//线程2获取资源2后,进入睡眠状态
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前线程:"+Thread.currentThread().getName()+"获取资源"+"resource2");
System.out.println("当前线程:"+Thread.currentThread().getName()+"尝试获取资源resource1......");
synchronized (resource1){//线程2尝试获取资源1
System.out.println("当前线程:"+Thread.currentThread().getName()+"获取资源"+"resource1");
}
}
});
}
}
//资源类
class Resource{
private String id;
private String name;
}
3.出现死锁的解决思路
3.1Java程序出现死锁
-
日志和异常信息:查看Java应用程序的日志文件以及堆栈跟踪信息。通常,当发生死锁时,会在日志中记录异常信息,包括哪些线程在等待哪些资源,有助于定位死锁问题。
-
JConsole 和 VisualVM:使用Java监控工具如JConsole和VisualVM来监视应用程序的线程状态。这些工具可以提供线程的堆栈跟踪信息和线程的状态,以帮助识别死锁。
-
使用线程转储工具:Java提供了一些线程转储工具,如jstack,它可以生成Java应用程序的线程转储。线程转储可以帮助你分析线程的状态和锁定情况,从而识别死锁。
jstack <pid>
-
使用工具检测死锁:有一些专门的工具可以检测Java应用程序中的死锁,如jvisualvm和jstack。这些工具可以自动检测并报告死锁问题。
-
代码审查:检查应用程序的源代码,特别是多线程代码,以确定是否存在可能导致死锁的问题,如线程之间的资源竞争、不当的锁顺序等。
-
资源监控:监视系统资源使用情况,如CPU、内存、磁盘等。如果系统资源已经耗尽,可能会导致线程无法执行,从而出现死锁。
一旦识别出死锁,可以采取以下措施来解决问题:
中止一个或多个线程,以释放资源。
重新设计多线程代码,避免死锁发生。
使用同步工具,如ReentrantLock和Semaphore,以更精细地控制线程的同步。
使用死锁检测和解除死锁算法来处理死锁情况。
4.2系统解决
-
避免死锁:通过设计和算法上的调整,避免死锁的发生。这可以通过破坏死锁四个必要条件之一来实现。
考虑一个简单的资源分配问题,有两个线程,分别需要资源A和B。如果一个线程需要A后才请求B,而另一个线程需要B后才请求A,那么它们就不会同时占有这两个资源,从而避免了死锁。
-
检测和解除死锁:使用死锁检测算法来定期检测系统中是否存在死锁。一旦检测到死锁,可以采取措施来解除死锁。这通常包括终止某些线程或者回滚操作。
在数据库管理系统中,如果多个事务之间出现了死锁,数据库管理系统可以检测到这种情况,然后选择中止一个或多个事务,以解除死锁。
-
超时和重试:在资源请求时,设置一个超时时间。如果资源无法在规定时间内获得,线程可以放弃请求或者重试。
在分布式系统中,如果一个服务请求另一个服务的响应,可以设置超时时间。如果在超时时间内未收到响应,可以重试请求或者执行其他操作。
-
资源分级:为资源分配引入优先级,使得资源分配不会导致循环等待。
在操作系统中,文件系统可以分配资源访问的优先级,使得某些任务在等待文件资源时不会阻塞其他任务。
-
资源分配图:引入资源分配图,检测潜在的死锁情况,并根据图的结构来解除死锁。
操作系统中使用资源分配图来检测和解除死锁。如果资源分配图中存在环路,就表示可能发生死锁,系统会选择终止其中一个进程以解除死锁。
4.经典案例:哲学家进餐问题
哲学家进餐问题(Dining Philosophers Problem)是一个经典的多线程同步问题,它描述了五位哲学家坐在圆桌前,每人面前有一盘面条,他们交替进行思考和进餐。哲学家之间的问题是如何共享这五个筷子,以避免死锁(每人拿一只筷子,都无法拿到第二只筷子)和竞争条件(多人同时尝试拿起一只筷子)。
下面是一个简化的哲学家进餐问题的示例解决方案,使用Java中的多线程和ReentrantLock来解决:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class DiningPhilosophers {
private static final int NUM_PHILOSOPHERS = 5;
private static Philosopher[] philosophers = new Philosopher[NUM_PHILOSOPHERS];
private static Fork[] forks = new Fork[NUM_PHILOSOPHERS];
public static void main(String[] args) {
for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
forks[i] = new Fork();
}
for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
philosophers[i] = new Philosopher(i, forks[i], forks[(i + 1) % NUM_PHILOSOPHERS]);
new Thread(philosophers[i]).start();
}
}
static class Fork {
private Lock lock = new ReentrantLock();
public void pickUp() {
lock.lock();
}
public void putDown() {
lock.unlock();
}
}
static class Philosopher implements Runnable {
private int id;
private Fork leftFork;
private Fork rightFork;
public Philosopher(int id, Fork leftFork, Fork rightFork) {
this.id = id;
this.leftFork = leftFork;
this.rightFork = rightFork;
}
public void eat() {
System.out.println("Philosopher " + id + " is eating.");
}
public void think() {
System.out.println("Philosopher " + id + " is thinking.");
}
@Override
public void run() {
while (true) {
think();
leftFork.pickUp();
System.out.println("Philosopher " + id + " picked up left fork.");
rightFork.pickUp();
System.out.println("Philosopher " + id + " picked up right fork.");
eat();
leftFork.putDown();
System.out.println("Philosopher " + id + " put down left fork.");
rightFork.putDown();
System.out.println("Philosopher " + id + " put down right fork.");
}
}
}
}
这个示例使用了ReentrantLock来表示每个筷子,并确保每位哲学家都遵守“拿左边筷子->拿右边筷子->吃饭->放下筷子”的顺序。这样,它能够避免死锁,并保证每个哲学家都能进餐。在实际应用中,可能需要更复杂的算法来处理哲学家进餐问题,特别是在更大规模的环境中。