多线程编程：Java中的死锁现象实例

原创 Love The Way You Lie 2024-10-24 07:12 51阅读 0赞

在Java多线程编程中，死锁是一种常见的问题。简单来说，当两个或更多的线程互相等待对方释放资源时，就会发生死锁。

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

```java
// 线程1需要获取锁A和锁B
public class Thread1 extends Thread {
    private Object lockA;
    private Object lockB;

public Thread1(Object lockA, Object lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

@Override
    public void run() {
        try {
            synchronized (lockA) {
                // 线程1获取锁A后，需要获取锁B
                synchronized (lockB) {
                    System.out.println("Thread 1 acquired locks A and B");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 线程2需要获取锁B和锁C
public class Thread2 extends Thread {
    private Object lockB;
    private Object lockC;

public Thread2(Object lockB, Object lockC) {
        this.lockB = lockB;
        this.lockC = lockC;
    }

@Override
    public void run() {
        try {
            synchronized (lockB) {
                // 线程2获取锁B后，需要获取锁C
                synchronized (lockC) {
                    System.out.println("Thread 2 acquired locks B and C");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(new Object(), new Object()));
        Thread2 thread2 = new Thread2(new Object(), new Object()));

thread1.start();
        thread2.start();

// 线程1和线程2需要等待对方释放资源
        // 这会导致死锁，因为两个线程互相等待
    }
}
```

在这个例子中，`Thread1`需要先获取`lockA`和`lockB`，然后获取`lockB`和`lockC`。而`Thread2`的顺序是相反的。

如果两个线程按照这样的顺序请求锁，那么就会发生死锁，因为一个线程等待另一个线程释放资源，而另一个线程也在等待。