java并发编程—死锁

死锁

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

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

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，这样就避免了死锁的发生。