多线程 - 什么是线程死锁？怎么避免？

骑猪看日落 2023-09-26 19:15 36阅读 0赞

线程死锁是指两个或多个线程相互等待对方释放锁资源，导致所有线程都无法继续执行的一种情况。如果不处理，死锁会导致应用程序的异常终止，降低系统的可用性。

线程死锁的避免可以从以下几个方面入手：

1、避免一个线程同时获取多个锁。如果不可避免，可以统一获取锁的顺序，避免交叉获取锁导致死锁。  
2、避免一个线程在等待另一个线程持有的锁的同时，还持有自己的锁。可以在持有锁的时候，尽快处理完需要持有锁的逻辑，释放锁资源。  
3、尽量减少锁的持有时间。可以使用并发容器等无锁数据结构，减少锁的竞争。  
4、可以使用线程池和定时器来避免死锁。可以设置超时时间，如果等待超时则释放锁资源，并记录日志。  
5、可以使用工具来检测死锁。Java中提供了一个工具jstack，可以用来检测死锁线程的状态和调用栈信息，从而及时发现和解决死锁问题。

需要注意的是，避免线程死锁需要在设计和编写代码的过程中就考虑，这样才能从根本上避免线程死锁的发生。

## 线程死锁的代码示例： ##

public class DeadlockExample {
        
        public static Object lock1 = new Object();
        public static Object lock2 = new Object();
    
        public static void main(String[] args) {
        
            Thread thread1 = new Thread(new Runnable() {
        
                public void run() {
        
                    synchronized (lock1) {
        
                        try {
         Thread.sleep(100);} catch (InterruptedException e) {
        }
                        synchronized (lock2) {
        
                            System.out.println("Thread 1: Acquired lock1 and lock2.");
                        }
                    }
                }
            });
            Thread thread2 = new Thread(new Runnable() {
        
                public void run() {
        
                    synchronized (lock2) {
        
                        try {
         Thread.sleep(100);} catch (InterruptedException e) {
        }
                        synchronized (lock1) {
        
                            System.out.println("Thread 2: Acquired lock2 and lock1.");
                        }
                    }
                }
            });
            thread1.start();
            thread2.start();
        }
    }

避免死锁的代码案例：

public class DeadlockAvoidanceExample {
        
        public static Object lock1 = new Object();
        public static Object lock2 = new Object();
    
        public static void main(String[] args) {
        
            Thread thread1 = new Thread(new Runnable() {
        
                public void run() {
        
                    synchronized (lock1) {
        
                        try {
         Thread.sleep(100);} catch (InterruptedException e) {
        }
                        synchronized (lock2) {
        
                            System.out.println("Thread 1: Acquired lock1 and lock2.");
                        }
                    }
                }
            });
            Thread thread2 = new Thread(new Runnable() {
        
                public void run() {
        
                    synchronized (lock1) {
        
                        try {
         Thread.sleep(100);} catch (InterruptedException e) {
        }
                        synchronized (lock2) {
        
                            System.out.println("Thread 2: Acquired lock1 and lock2.");
                        }
                    }
                }
            });
            thread1.start();
            thread2.start();
        }
    }

这里我们改变了代码，让两个线程获取锁的顺序一致。这样就避免了死锁的情况。注意：避免死锁的最好方式是在设计阶段避免，而不是在代码实现时解决。