Java线程面试题：什么是死锁？如何避免？

古城微笑少年丶 2024-03-16 17:02 22阅读 0赞

## 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` 的锁。由于两个线程都在等待对方释放所持有的锁，因此出现了死锁情况。

避免死锁一般采用以下策略：

1.  避免使用多个同步锁，尽量减少竞争情况；
2.  保证获取锁的顺序，从而避免循环依赖；
3.  使用定时锁来限制等待时间，超过一定时间后释放资源重新尝试获取。

修改代码如下：

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` 的锁，从而解除了死锁情况。

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