Java多线程：死锁实例分析

原创迷南。 2024-09-12 06:18 90阅读 0赞

在Java多线程编程中，死锁是一种常见的问题。简单来说，死锁发生时，两个或更多的线程因争夺资源而造成的一种互相等待的现象，且这种状态无法通过各自释放已获取的资源来打破。

下面是一个简单的Java死锁示例：

```java
// 线程A
class ThreadA implements Runnable {
    private Object lockA = new Object();
    private Object lockB = new Object();

@Override
    public void run() {
        while (true) { // 无限循环
            synchronized (lockA) {
                System.out.println("Thread A: Trying to acquire lock B");
                
                // 线程B的运行
                if (threadB != null && threadB.isRunning()) {
                    synchronized (lockB) {
                        System.out.println("Thread B: Trying to acquire lock A");

// 确保资源在释放之前被正确获取
                        if (lockA.tryAcquire(100)) {
                            System.out.println("Thread B: Lock A acquired");
                            lockB.notifyAll(); // 通知线程B锁B已准备好释放

// 线程A进入等待状态
                            lockA.lock();
                            System.out.println("Thread A: Lock A acquired");

break; // 退出无限循环
                        } else {
                            System.out.println("Thread B: Lock A acquisition failed");
                            break; // 退出无限循环
                        }
                    }

System.out.println("Thread B: Lock B acquired, notify Thread A");
                    lockB.notifyAll(); // 通知线程A锁B已准备好释放

// 线程A进入等待状态
                    lockA.unlock();
                    System.out.println("Thread A: Unlock A");

break; // 退出无限循环
                } else {
                    System.out.println("Thread B: Thread B is stopped, cannot acquire lock");
                    break; // 退出无限循环
                }
            }

System.out.println("Thread A: Exiting loop, sleeping for 1 second");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 线程B
class ThreadB implements Runnable {
    private Object lockA = new Object();
    private Object lockB = new Object();

@Override
    public void run() {
        while (true) { // 无限循环
            synchronized (lockB) {
                System.out.println("Thread B: Trying to acquire lock A");

// 确保资源在释放之前被正确获取
                if (lockA.tryAcquire(100)) {
                    System.out.println("Thread B: Lock A acquired");
                    lockB.notifyAll(); // 通知线程A锁B已准备好释放

// 线程A进入等待状态
                    lockA.lock();
                    System.out.println("Thread A: Lock A acquired");

break; // 退出无限循环
                } else {
                    System.out.println("Thread B: Lock A acquisition failed");
                    break; // 退出无限循环
                }
            }

System.out.println("Thread B: Exiting loop, sleeping for 1 second");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

// 启动线程
        new Thread(threadA).start();
        new Thread(threadB).start();
    }
}
```

在这个例子中，两个线程`ThreadA`和`ThreadB`试图同时获取锁资源。如果一个线程在获取锁之前已经被另一个线程持有，则当前线程会一直等待。

这样的设计会导致死锁状态，因为没有线程能通过释放已持有的锁来打破死锁循环。