Java多线程并发问题案例展示

原创客官°小女子只卖身不卖艺 2024-11-14 07:00 10阅读 0赞

Java多线程并发问题通常涉及到线程安全、死锁、竞态条件等问题。以下是一些常见的并发问题案例：

###1.线程安全问题**案例：共享资源访问**

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

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

public int getCount() {
 return count;
 }
}
```在这个例子中，`increment` 方法不是线程安全的，因为 `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.死锁问题**案例：两个资源同时被两个线程锁定**

```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.竞态条件**案例：打印数字**

```javapublic class RaceConditionExample {
 private int number =0;

public void printNumber() {
 System.out.println(number);
 number++;
 }
}
```如果多个线程同时调用 `printNumber` 方法，可能会导致输出的数字不正确，因为 `System.out.println(number)` 和 `number++`之间存在竞态条件。

**解决方案：**

使用 `synchronized` 关键字或者 `AtomicInteger`来确保操作的原子性。

```javapublic class RaceConditionExample {
 private AtomicInteger number = new AtomicInteger(0);

public void printNumber() {
 System.out.println(number.getAndIncrement());
 }
}
```###4.可见性问题**案例：变量更新不可见**

```javapublic class VisibilityExample {
 private boolean flag = false;
 private int number =0;

public void writer() {
 number =10;
 flag = true;
 }

public void reader() {
 while (!flag) {
Thread.yield();
 }
 System.out.println(number);
 }
}
```在这个例子中，即使 `writer`线程更新了 `number` 的值，`reader`线程可能看不到这个更新，因为 `flag` 的更新和 `number` 的更新之间存在可见性问题。

**解决方案：**

使用 `volatile` 关键字来确保变量的可见性。

```javapublic class VisibilityExample {
 private volatile boolean flag = false;
 private int number =0;

public void writer() {
 number =10;
 flag = true;
 }

public void reader() {
 while (!flag) {
Thread.yield();
 }
 System.out.println(number);
 }
}
```这些案例展示了Java多线程并发中的一些常见问题及其解决方案。在实际开发中，需要根据具体情况选择合适的并发控制机制。