理解并避免Java中的并发问题实例

原创古城微笑少年丶 2024-11-13 23:55 22阅读 0赞

在Java中，多线程编程是常见的，但并发问题也随之产生。以下是一些常见的并发问题以及如何避免它们的实例：

###1.竞态条件（Race Condition）

**问题描述**：当多个线程访问共享数据时，如果至少有一个线程在修改数据，而其他线程在读取数据，那么最终的结果可能依赖于线程执行的顺序。

**避免方法**：使用同步机制，如`synchronized`关键字、`ReentrantLock`等。

**示例代码**：

```javapublic class Counter {
 private int count =0;

public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return count;
 }
}
```###2.死锁（Deadlock）

**问题描述**：两个或多个线程在等待对方释放资源，导致它们永远阻塞。

**避免方法**：确保线程以相同的顺序请求资源，或者使用超时机制。

**示例代码**：

```javapublic class DeadlockAvoidance {
 private final Object resource1 = new Object();
 private final Object resource2 = new Object();

public void method1() {
 synchronized (resource1) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource2) {
// do something }
 }
 }

public void method2() {
 synchronized (resource2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource1) {
// do something }
 }
 }
}
```###3.活锁（Livelock）

**问题描述**：线程在尝试执行任务时，由于某些条件不满足而不断重复尝试，但始终不成功。

**避免方法**：设计算法时避免循环等待，或者引入随机化等待时间。

###4.资源泄露（Resource Leak）

**问题描述**：线程在执行过程中未能释放资源，导致资源耗尽。

**避免方法**：确保资源在使用后被正确释放，使用`try-with-resources`语句。

**示例代码**：

```javapublic class ResourceLeakExample {
 public void processFile(String fileName) {
 try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
 while ((line = reader.readLine()) != null) {
// process line }
} catch (IOException e) {
e.printStackTrace();
 }
 }
}
```###5.可见性问题（Visibility）

**问题描述**：一个线程修改了共享变量的值，但其他线程看不到这个变化。

**避免方法**：使用`volatile`关键字或`synchronized`块。

**示例代码**：

```javapublic class VisibilityExample {
 private volatile boolean running = true;

public void stop() {
 running = false;
 }

public void doWork() {
 while (running) {
// do work }
 }
}
```###6.原子性问题（Atomicity）

**问题描述**：一个操作需要多个步骤完成，但在多线程环境下，这些步骤可能会被其他线程中断。

**避免方法**：使用`Atomic`类，如`AtomicInteger`，或者使用`synchronized`。

**示例代码**：

```javaimport java.util.concurrent.atomic.AtomicInteger;

public class AtomicityExample {
 private AtomicInteger count = new AtomicInteger(0);

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