java并发编程—死锁

淩亂°似流年 2023-10-12 12:34 69阅读 0赞

### 死锁 ###

死锁是指两个或多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法继续执行下去。

死锁的解决方法有以下几种：

1.  避免死锁：通过合理的资源分配策略，避免进程之间发生资源争夺的情况，从而避免死锁的发生。
2.  检测死锁：通过系统资源分配表和进程等待表来检测死锁的发生，一旦发现死锁，就采取相应的措施进行解除。
3.  避免和检测死锁的结合：综合运用前两种方法，既避免死锁的发生，又在必要时检测死锁并解除。

下面是一个简单的Java代码示例，演示了死锁的情况以及如何通过避免死锁的方法来解决：

public class DeadlockExample {
        
        private static Object lock1 = new Object();
        private static Object lock2 = new Object();
    
        public static void main(String[] args) {
        
            Thread thread1 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (lock1) {
        
                        System.out.println("Thread 1: Holding lock 1...");
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println("Thread 1: Waiting for lock 2...");
                        synchronized (lock2) {
        
                            System.out.println("Thread 1: Holding lock 1 and lock 2...");
                        }
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (lock2) {
        
                        System.out.println("Thread 2: Holding lock 2...");
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println("Thread 2: Waiting for lock 1...");
                        synchronized (lock1) {
        
                            System.out.println("Thread 2: Holding lock 1 and lock 2...");
                        }
                    }
                }
            });
    
            thread1.start();
            thread2.start();
        }
    }

在上面的代码中，两个线程分别占用了lock1和lock2两个锁，并且在互相等待对方释放锁的情况下，就会发生死锁。为了避免死锁的发生，我们可以通过改变锁的获取顺序来避免，如下所示：

public class DeadlockExample {
        
        private static Object lock1 = new Object();
        private static Object lock2 = new Object();
    
        public static void main(String[] args) {
        
            Thread thread1 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (lock1) {
        
                        System.out.println("Thread 1: Holding lock 1...");
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println("Thread 1: Waiting for lock 2...");
                        synchronized (lock2) {
        
                            System.out.println("Thread 1: Holding lock 1 and lock 2...");
                        }
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (lock1) {
        
                        System.out.println("Thread 2: Holding lock 1...");
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println("Thread 2: Waiting for lock 2...");
                        synchronized (lock2) {
        
                            System.out.println("Thread 2: Holding lock 1 and lock 2...");
                        }
                    }
                }
            });
    
            thread1.start();
            thread2.start();
        }
    }

在上面的代码中，我们将线程2的锁获取顺序改为先获取lock1，再获取lock2，这样就避免了死锁的发生。