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 的锁，从而解除了死锁情况。
总结：死锁是一种常见的并发问题，可以通过避免使用多个同步锁、保证获取锁的顺序和使用定时锁等策略来避免。在进行并发编程时，应当尽量避免出现死锁问题，以保障程序运行的稳定性和正确性。
