Java多线程同步问题：死锁与活锁案例

原创系统管理员 2024-11-13 05:12 39阅读 0赞

在Java中，多线程同步问题主要涉及到线程间的协调和资源管理。死锁和活锁是两种常见的同步问题，它们都会导致程序无法正常运行。下面我将分别解释死锁和活锁，并给出相应的案例。

###死锁（Deadlock）

死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，若无外力作用，它们都将无法继续向前推进。死锁发生必须同时满足以下四个条件：

1. **互斥条件**：资源不能被多个线程共享，只能由一个线程使用。
2. **占有和等待条件**：一个线程至少占有一个资源，并且等待获取其他线程占有的资源。
3. **不可剥夺条件**：资源只能由占有它的线程自愿释放。
4. **循环等待条件**：存在一个线程的集合，其中每个线程都在等待下一个线程所占有的资源。

**死锁案例**：

```javapublic class DeadlockExample {
 private static final Object lock1 = new Object();
 private static final Object lock2 = new Object();

public static void main(String[] args) {
 new Thread(() -> {
 synchronized (lock1) {
 System.out.println("Thread1: Locked lock1");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Thread1: Locked lock2");
 }
 }
 }).start();

new Thread(() -> {
 synchronized (lock2) {
 System.out.println("Thread2: Locked lock2");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Thread2: Locked lock1");
 }
 }
 }).start();
 }
}
```在这个例子中，两个线程分别尝试先锁定`lock1`和`lock2`，然后锁定另一个锁，这导致了死锁。

###活锁（Livelock）

活锁是指两个或多个线程在运行过程中，由于某些条件不满足，导致它们不断重复尝试获取资源，但始终无法继续执行。与死锁不同，活锁中的线程是“活”的，它们没有被阻塞，但由于某种机制，它们不断重试，导致无法取得进展。

**活锁案例**：

```javapublic class LivelockExample {
 private static final Object lock1 = new Object();
 private static final Object lock2 = new Object();

public static void main(String[] args) {
 new Thread(() -> {
 while (true) {
 synchronized (lock1) {
if (lock2.tryLock()) {
 try {
 System.out.println("Thread1: Locked lock1 and lock2");
} finally {
 lock2.unlock();
 }
 break;
 }
 }
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }).start();

new Thread(() -> {
 while (true) {
 synchronized (lock2) {
if (lock1.tryLock()) {
 try {
 System.out.println("Thread2: Locked lock1 and lock2");
} finally {
 lock1.unlock();
 }
 break;
 }
 }
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }).start();
 }
}
```在这个例子中，两个线程尝试使用`tryLock()`来获取锁，如果获取失败，它们会释放当前持有的锁并重试。这可能导致两个线程不断尝试获取对方的锁，但始终无法成功，形成活锁。

解决这些问题通常需要重新设计线程间的同步机制，确保资源的合理分配和释放，或者使用更高级的同步工具，如`ReentrantLock`、`Semaphore`等。