多线程并发：Java线程同步死锁案例

原创落日映苍穹つ 2024-09-18 01:03 13阅读 0赞

在Java编程中，多线程并发和线程同步是两个重要的概念。下面我们将通过一个死锁的例子来深入理解。

首先，了解什么是死锁：
- 死锁：两个或更多的线程因争夺资源而造成的一种互相等待的现象，若无外力干涉无法继续执行任何操作。

现在我们来看一个Java死锁案例：

```java
// 线程1
public class Thread1 extends Thread {
    private Object lockA = new Object();
    private Object lockB = new Object();

public void run() {
        synchronized (lockA) { // 获取锁A
            System.out.println("Thread1: Acquired lockA");
            
            try {
                // 代码块
                synchronized (lockB) { // 同时获取锁B
                    System.out.println("Thread1: Attempting to acquire lockB");
                    
                    if (Thread.currentThread() != lockB.getOwner()) {
                        // 如果线程不是锁的当前拥有者，则等待
                        lockB.acquire();
                        System.out.println("Thread1: Acquired lockB after waiting");
                    } else {
                        System.out.println("Thread1: LockB is already acquired by " + lockB.getOwner()));
                    }
                } catch (InterruptedException e) {
                    System.out.println("Thread1: InterruptedException occurred in lockB acquire");
                    Thread.currentThread().interrupt();
                }
            } finally { // 无论是否获取锁，都需要释放
                synchronized (lockA) {
                    lockA.release();
                    System.out.println("Thread1: Released lockA");
                }

synchronized (lockB) {
                    lockB.release();
                    System.out.println("Thread1: Released lockB");
                }
            }
        } // 获取锁A释放
    }

public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start();

// 创建另一个线程尝试获取锁A
        Thread2 thread2 = new Thread2(thread1);
        thread2.start();
    }
}

// 线程2，尝试获取锁A
public class Thread2 extends Thread {
    private Object lockA = new Object();

public Thread2(Thread1 parentThread) {
        this.parentThread = parentThread;
    }

public void run() {
        try {
            // 获取锁A
            synchronized (lockA) {
                System.out.println("Thread2: Attempting to acquire lockA from " + parentThread);
                
                if (parentThread != null && !parentThread.isLockAAcquired()) { // 如果线程不是父线程，且没有获取锁A，则尝试获取锁
                    lockA.acquire();
                    System.out.println("Thread2: Acquired lockA successfully");

// 设置父线程的锁状态
                    if (parentThread != null) {
                        parentThread.setLockAAcquired(true);
                        System.out.println("Thread2: Set parent thread's lockA state to true");
                    }
                } else { // 如果线程是父线程或已经获取了锁，那么尝试获取锁会失败
                    System.out.println("Thread2: Failed to acquire lockA from " + parentThread + ", already acquired by the parent thread.");
                }
            }
        } catch (InterruptedException e) {
            System.out.println("Thread2: InterruptedException occurred in lockA acquire");
            Thread.currentThread().interrupt();
        }

}
}
```

在这个例子中，线程1获取了锁A后试图获取锁B。但是线程2，作为另一个线程，也尝试获取锁A。由于线程1已经在等待线程2释放锁A时才进行尝试，所以当线程2尝试获取锁A时，会发现已被线程1占用，从而引发死锁。

在实际编程中，为了避免死锁的发生，需要遵循以下原则：
1. 互斥：资源在被访问的时刻必须是独占的。
2. 不剥夺：进程一旦获得了资源就不能被剥夺。
3. 非循环等待：任何时刻不存在循环等待的关系。