Java并发编程：死锁问题实例分析

原创 àì夳堔傛蜴生んèń 2024-09-19 04:30 92阅读 0赞

在Java并发编程中，死锁是一个常见的问题。简单来说，死锁发生时，两个或更多的进程因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法继续执行。

以下是一个简单的死锁实例：

```java
// 线程1
class ThreadOne implements Runnable {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

@Override
    public void run() {
        synchronized (lock1) {
            System.out.println("Thread 1 acquiring lock1");
            try {
                // 等待获取锁2
                synchronized (lock2) {
                    System.out.println("Thread 1 acquiring lock2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 第二部分，释放锁1
        System.out.println("Thread 1 releasing lock1");
        synchronized (lock1) {
            lock1.notifyAll();
        }

// 第三部分，尝试获取并释放锁2
        try {
            // 等待获取锁2
            synchronized (lock2) {
                System.out.println("Thread 1 trying to acquire lock2");
                lock2.notifyAll();
            }

// 获取并释放锁2
            synchronized (lock2) {
                System.out.println("Thread 1 acquiring and releasing lock2");
                lock2.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 线程2
class ThreadTwo implements Runnable {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

@Override
    public void run() {
        synchronized (lock1) {
            System.out.println("Thread 2 acquiring lock1");
            try {
                // 等待获取锁2
                synchronized (lock2) {
                    System.out.println("Thread 2 acquiring lock2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 第二部分，释放锁1
        System.out.println("Thread 2 releasing lock1");
        synchronized (lock1) {
            lock1.notifyAll();
        }

// 第三部分，尝试获取并释放锁2
        try {
            // 等待获取锁2
            synchronized (lock2) {
                System.out.println("Thread 2 trying to acquire lock2");
                lock2.notifyAll();
            }

// 获取并释放锁2
            synchronized (lock2) {
                System.out.println("Thread 2 acquiring and releasing lock2");
                lock2.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadOne thread1 = new ThreadOne();
        ThreadTwo thread2 = new ThreadTwo();

// 启动线程
        thread1.start();
        thread2.start();
    }
}
```

在这个例子中，线程1等待获取锁2，同时线程2也等待获取锁1。由于两个线程都处于等待状态，因此会出现死锁。