Java线程同步不当引发死锁示例

原创 ╰+攻爆jí腚メ 2024-10-19 08:45 20阅读 0赞

在Java编程中，线程同步主要是通过synchronized关键字实现的。如果同步控制不当，就可能会导致死锁的发生。

以下是一个简单的死锁示例，使用了两个共享资源（Lock1和Lock2）：

```java
public class DeadlockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

// 线程A的代码
    public void threadA() {
        synchronized (lock1) {
            System.out.println("Thread A: Acquiring Lock1");
            try {
                synchronized (lock2) {
                    System.out.println("Thread A: Acquiring Lock2 inside lock1");
                    // 这里可能会阻塞，导致死锁
                    Thread.sleep(500); // 模拟阻塞操作
                }
                System.out.println("Thread A: Releasing Lock2 after acquiring Lock1");
            } catch (InterruptedException e) {
                System.out.println("Thread A: Interrupted while acquiring Lock1");
                e.printStackTrace();
            }
        }

System.out.println("Thread A: Exiting threadA");
    }

// 线程B的代码
    public void threadB() {
        synchronized (lock2) {
            System.out.println("Thread B: Acquiring Lock2 before threadA can acquire Lock1");
            try {
                Thread.sleep(500); // 模拟阻塞操作，使得线程B有机会先获取锁2
            } catch (InterruptedException e) {
                System.out.println("Thread B: Interrupted while acquiring Lock2");
                e.printStackTrace();
            }
        }

synchronized (lock1) {
            System.out.println("Thread B: Acquiring Lock1 after threadA has acquired Lock2");
            try {
                Thread.sleep(500); // 模拟阻塞操作，使线程B有机会获取锁1
            } catch (InterruptedException e) {
                System.out.println("Thread B: Interrupted while acquiring Lock1");
                e.printStackTrace();
            }
        }

System.out.println("Thread B: Exiting threadB");
    }

public static void main(String[] args) {
        ThreadA tA = new ThreadA();
        ThreadB tB = new ThreadB();

tA.start();
        tB.start();
    }
}
```

在这个例子中，线程A首先获取锁1，然后尝试获取锁2。由于线程B先获取了锁2，所以在线程A获取锁2之前，它无法继续获取锁1。

这就导致了死锁：两个或更多的线程因竞争资源而造成的一种互相等待的现象，若无外力作用它们将无法继续执行。