理解Java多线程并发问题案例

原创淡淡的烟草味﹌ 2024-12-05 20:09 16阅读 0赞

Java多线程并发问题主要涉及到线程同步、死锁、资源泄露等问题，下面是一些具体案例：

1. 同步问题：例如生产者消费者问题。如果多个消费者同时尝试获取资源（如食物），可能会导致数据不一致。

```java
// 假设队列是无界的
public class ProducerConsumer {
    private final Queue<String> queue = new ArrayDeque<>();

public void produce() throws InterruptedException {
        while (true) {
            queue.put("Product " + queue.size());
            System.out.println("Produced: " + queue.poll());
            if (!queue.isEmpty()) { // 如果队列非空，继续生产
                break;
            }
        }
    }

public void consume() throws InterruptedException {
        while (true) {
            String product = queue.poll();
            if (product != null) { // 产品不为空，消费成功
                System.out.println("Consumed: " + product);
            } else { // 如果队列为空，代表所有产品都已经被消费完毕，退出循环
                break;
            }
        }
    }

public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        new Thread(pc::produce).start();
        new Thread(pc::consume).start();
    }
}
```

2. 死锁：如果两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，就称为死锁。

```java
// 假设两个线程互斥访问同一个资源
public class DeadLockExample {
    private int lock1 = 0;
    private int lock2 = 0;

public void acquireLock1() throws InterruptedException {
        while (lock1 != 0) { // 如果锁1未释放，继续等待
            Thread.sleep(50); // 模拟线程等待时间
        }
        System.out.println("Acquired lock1.");
        lock1 = 1;
    }

public void acquireLock2() throws InterruptedException {
        while (lock2 != 0) { // 如果锁2未释放，继续等待
            Thread.sleep(50); // 模拟线程等待时间
        }
        System.out.println("Acquired lock2.");
        lock2 = 1;
    }

public static void main(String[] args) {
        DeadLockExample example = new DeadLockExample();
        new Thread(example::acquireLock1).start();
        new Thread(example::acquireLock2)).start();
    }
}
```

3. 资源泄露：当一个线程持有某个资源但未释放时，就可能导致资源泄露。例如，静态变量如果被一个线程长时间持有，可能会导致其他线程无法访问。

```java
// 资源泄露案例：静态变量被线程锁定
public class StaticVariableLeak {
    private static int count = 0;

public void incrementCount() {
        synchronized (StaticVariableLeak.class) { // 同步处理，确保原子性
            count++;
        }
    }

public static void main(String[] args) {
        StaticVariableLeak leaker = new StaticVariableLeak();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                leaker.incrementCount(); // 模拟线程操作
            }
        })).start();

try {
            System.out.println("Final count: " + count); // 检查最终的count值
            Thread.sleep(2000); // 确保主线程完成所有操作，否则可能会造成资源泄露检查不准确
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上是Java多线程并发问题的一些案例。理解和解决这些问题需要深入理解Java并发模型和相关的API。