实例探讨：Java多线程并发问题

原创﹏ヽ暗。殇╰゛Y 2024-11-12 01:09 15阅读 0赞

Java多线程并发问题是一个复杂而广泛的话题，涉及到线程的创建、同步、死锁、竞态条件等多个方面。以下是一些常见的并发问题和解决方案的实例探讨：

###1.竞态条件（Race Condition）
**问题描述**：当多个线程访问共享数据时，如果至少有一个线程在修改数据，而其他线程可以同时读取这些数据，就可能发生竞态条件。

**示例代码**：
```javapublic class Counter {
 private int count =0;

public void increment() {
 count++; //非原子操作 }

public int getCount() {
 return count;
 }
}
```
在这个例子中，`increment()` 方法不是原子的，因为它涉及到读取、增加和写入三个步骤。如果多个线程同时调用这个方法，可能会导致`count`的值不正确。

**解决方案**：使用`synchronized`关键字或`AtomicInteger`类来确保操作的原子性。
```javapublic class Counter {
 private AtomicInteger count = new AtomicInteger(0);

public void increment() {
 count.incrementAndGet();
 }

public int getCount() {
 return count.get();
 }
}
```###2.死锁（Deadlock）
**问题描述**：当两个或多个线程在等待对方释放资源时，它们都阻塞了，无法继续执行。

**示例代码**：
```javapublic class DeadlockExample {
 private final Object lock1 = new Object();
 private final Object lock2 = new Object();

public void method1() {
 synchronized (lock1) {
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Lock2 acquired");
 }
 }
 }

public void method2() {
 synchronized (lock2) {
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Lock1 acquired");
 }
 }
 }
}
```
在这个例子中，如果`method1`和`method2`被不同的线程调用，它们可能会相互等待对方释放锁，导致死锁。

**解决方案**：确保所有线程以相同的顺序获取锁，或者使用`tryLock`方法尝试获取锁，并在失败时释放已持有的锁。

###3.线程饥饿（Thread Starvation）
**问题描述**：当一个或多个线程因为其他线程持续占用资源而无法执行时，就会发生线程饥饿。

**示例代码**：
```javapublic class StarvationExample {
 private final Object lock = new Object();

public void method1() {
 synchronized (lock) {
 while (true) {
 System.out.println("Thread1 is running");
 }
 }
 }

public void method2() {
 synchronized (lock) {
 System.out.println("Thread2 is running");
 }
 }
}
```
在这个例子中，`method1`中的无限循环会导致`method2`永远无法获取锁。

**解决方案**：避免无限循环，或者使用公平锁（`ReentrantLock`的公平模式）。

###4.活锁（Livelock）
**问题描述**：当两个或多个线程在尝试执行时，由于不断改变状态以响应对方的行为，导致它们无法取得进展。

**示例代码**：
```javapublic class LivelockExample {
 public void method1() {
 while (true) {
if (someCondition()) {
 doWork();
 break;
 }
 yield();
 }
 }

public void method2() {
 while (true) {
if (someCondition()) {
 doWork();
 break;
 }
 yield();
 }
 }
}
```
在这个例子中，两个方法可能会不断检查条件并让出CPU，导致活锁。

**解决方案**：重新设计算法，确保线程在等待一段时间后能够取得进展。

这些只是Java多线程并发问题的一些基本示例。在实际应用中，可能需要更复杂的设计和同步机制来确保线程安全和性能。