Java线程面试题:什么是死锁?如何避免?
死锁是指两个或多个线程相互等待对方持有的锁而不能继续执行,造成代码无法向下进行的情况。以下是一个简单的例子:
public class DeadLockDemo {
private static final Object lockA = new Object();
private static final Object lockB = new Object();
public static void main(String[] args) {
Thread threadA = new MyThreadA();
Thread threadB = new MyThreadB();
threadA.start();
threadB.start();
}
static class MyThreadA extends Thread {
@Override
public void run() {
synchronized (lockA) {
System.out.println("MyThreadA acquired lockA");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("MyThreadA is waiting for lockB...");
synchronized (lockB) {
System.out.println("MyThreadA acquired lockB");
}
}
}
}
static class MyThreadB extends Thread {
@Override
public void run() {
synchronized (lockB) {
System.out.println("MyThreadB acquired lockB");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("MyThreadB is waiting for lockA...");
synchronized (lockA) {
System.out.println("MyThreadB acquired lockA");
}
}
}
}
}
在这个例子中,我们创建了两个线程:MyThreadA
和MyThreadB
,分别竞争获取 lockA
和 lockB
这两个对象的锁。MyThreadA
获取到了lockA
的锁,进入临界区并休眠1秒钟,然后试图获取 lockB
的锁;而 MyThreadB
获取到了lockB
的锁,也进入临界区并休眠1秒钟,然后试图获取 lockA
的锁。由于两个线程都在等待对方释放所持有的锁,因此出现了死锁情况。
避免死锁一般采用以下策略:
- 避免使用多个同步锁,尽量减少竞争情况;
- 保证获取锁的顺序,从而避免循环依赖;
- 使用定时锁来限制等待时间,超过一定时间后释放资源重新尝试获取。
修改代码如下:
public class DeadLockDemo {
private static final Object lockA = new Object();
private static final Object lockB = new Object();
public static void main(String[] args) {
Thread threadA = new MyThreadA();
Thread threadB = new MyThreadB();
threadA.start();
threadB.start();
}
static class MyThreadA extends Thread {
@Override
public void run() {
synchronized (lockA) {
System.out.println("MyThreadA acquired lockA");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("MyThreadA is waiting for lockB...");
synchronized (lockB) {
System.out.println("MyThreadA acquired lockB");
}
}
}
}
static class MyThreadB extends Thread {
@Override
public void run() {
//保证获取锁的顺序,从而避免循环依赖
synchronized (lockA) {
System.out.println("MyThreadB acquired lockA");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("MyThreadB is waiting for lockB...");
synchronized (lockB) {
System.out.println("MyThreadB acquired lockB");
}
}
}
}
}
在 MyThreadB
中修改了竞争锁的获取顺序,使其先获取 lockA
的锁,从而解除了死锁情况。
总结:死锁是一种常见的并发问题,可以通过避免使用多个同步锁、保证获取锁的顺序和使用定时锁等策略来避免。在进行并发编程时,应当尽量避免出现死锁问题,以保障程序运行的稳定性和正确性。