探索Java多线程并发问题案例

原创电玩女神 2024-11-01 19:51 5阅读 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` 类来确保线程安全。

###2.死锁**案例：两个资源同时被锁定**

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

public static void main(String[] args) {
 new Thread(() -> {
 synchronized (resource1) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource2) {
 System.out.println("Thread1 acquired both resources");
 }
 }
 }).start();

new Thread(() -> {
 synchronized (resource2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource1) {
 System.out.println("Thread2 acquired both resources");
 }
 }
 }).start();
 }
}
```在这个例子中，两个线程分别尝试获取两个资源，这可能导致死锁。

**解决方案：**确保所有线程以相同的顺序获取资源，或者使用 `tryLock` 方法尝试获取锁。

###3.竞态条件**案例：打印数字**

```javapublic class RaceConditionExample {
 private static int count =0;

public static void main(String[] args) {
 for (int i =0; i <10; i++) {
 new Thread(() -> {
 for (int j =0; j <1000; j++) {
 count++;
 }
 }).start();
 }
 while (Thread.activeCount() >1) {
Thread.yield();
 }
 System.out.println("Final count: " + count);
 }
}
```在这个例子中，多个线程同时增加 `count` 的值，可能导致最终的 `count`值小于预期。

**解决方案：** 使用 `synchronized` 关键字或者 `AtomicInteger` 类来确保线程安全。

###4.资源竞争**案例：生产者消费者问题**

```javapublic class ProducerConsumerExample {
 private static List<Integer> list = Collections.synchronizedList(new ArrayList<>());

public static void main(String[] args) {
 new Thread(() -> {
 for (int i =0; i <100; i++) {
 list.add(i);
 System.out.println("Produced: " + i);
 }
 }).start();

new Thread(() -> {
 for (int i =0; i <100; i++) {
int item = list.remove(0);
 System.out.println("Consumed: " + item);
 }
 }).start();
 }
}
```在这个例子中，生产者和消费者线程共享一个列表，可能会导致资源竞争问题。

**解决方案：** 使用 `synchronized` 关键字或者 `BlockingQueue`来确保线程安全。

这些案例展示了Java多线程并发中的一些常见问题。解决这些问题通常需要对线程安全、锁机制和并发工具类有深入的理解。