Java多线程同步：死锁、饥饿等问题示例

原创深藏阁楼爱情的钟 2024-09-15 10:30 68阅读 0赞

在Java编程中，多线程的同步是非常关键的一部分。它可以帮助我们避免一些诸如死锁（Dead Lock）、饥饿（Starvation）等问题。

1. **死锁**：当两个或更多的线程因争夺资源而造成的一种互相等待的现象称为死锁。

示例代码：
```java
class DeadLockExample {
    Object lock1 = new Object();
    Object lock2 = new Object();

void method1() {
        synchronized (lock1) {
            try {
                synchronized (lock2) {
                    // 这里的操作会导致两个线程都等待对方释放锁
                }
            } finally {
                lock1.notifyAll(); // 通知所有等待锁1的线程
            }
        }
    }

void method2() {
        synchronized (lock2) {
            try {
                synchronized (lock1) {
                    // 这里的操作会导致两个线程都等待对方释放锁
                }
            } finally {
                lock2.notifyAll(); // 通知所有等待锁2的线程
            }
        }
    }

public void startThreads() {
        new Thread(() -> method1()).start();
        new Thread(() -> method2()).start();
    }
}
```
当线程`method1`进入同步块并获取到锁`lock1`后，它等待锁`lock2`释放。同样，线程`method2`在等待锁`lock1`释放的同时，也在等待锁`lock2`释放。

这样的设计会导致两个线程都处于等待状态，从而产生死锁。

2. **饥饿（Starvation）**：当一个线程因为被剥夺执行机会而无法继续执行其任务时，就出现了饥饿现象。

示例代码：
```java
class StarvationExample {
    Object lock = new Object();

void task() {
        synchronized (lock) {
            lock.notifyAll(); // 通知所有等待锁的线程
            try {
                // 模拟耗时操作
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public void startTask() {
        new Thread(() -> task()).start();
    }
}
```
在这个例子中，线程`task`执行一个耗时的操作后通知所有等待锁的线程。然而，如果线程`task`被其他更高优先级的任务抢占，它将无法完成通知和耗时操作。

这种情况下，线程`task`就会发生饥饿现象。