Java多线程并发问题案例

原创桃扇骨 2024-10-13 01:24 48阅读 0赞

在Java多线程并发编程中，经常会遇到各种问题。以下是一些常见的问题案例：

1. **死锁**：
```java
// 假设两个线程A和B，
// A持有资源1并等待资源2,
// B持有资源2并等待资源1。

class Resource {
    Object obj;
    // 其他方法，如acquire(), release()
}

public class DeadLockExample {
    private final Resource resource1 = new Resource();
    private final Resource resource2 = new Resource();

public void runThreadA() {
        try {
            acquireResource(resource1);
            acquireResource(resource2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void runThreadB() {
        try {
            acquireResource(resource2);
            acquireResource(resource1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

// ... 实现acquire()和release()方法 ...

public static void main(String[] args) {
        DeadLockExample example = new DeadLockExample();
        Thread threadA = new Thread(example::runThreadA));
        Thread threadB = new Thread(example::runThreadB));

threadA.start();
        threadB.start();

// 等待两个线程都执行完毕
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
2. **资源争抢**：
```java
class Resource {
    Object obj;
    synchronized Object lock() {
        return obj;
    }

// ... 其他方法 ...
}

public class RaceConditionExample {
    private final Resource resource = new Resource();

public void consumeResource() {
        while (true) { // 无限循环
            if (resource.lock().equals(resource.obj)) {
                // 资源可用，执行耗时操作
                System.out.println("Consumed resource.");
                break; // 跳出循环，资源不再争抢
            }
        }
    }

public static void main(String[] args) {
        RaceConditionExample example = new RaceConditionExample();
        Thread thread1 = new Thread(() -> example.consumeResource()));
        Thread thread2 = new Thread(() -> example.consumeResource()));

thread1.start();
        thread2.start();

// 等待两个线程都执行完毕
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
3. **无界循环**：
```java
class InfiniteLoopExample {
    public void infiniteLoop() {
        while (true) { // 无限循环
            System.out.println("Infinite loop.");
        }
    }

public static void main(String[] args) {
        InfiniteLoopExample example = new InfiniteLoopExample();
        Thread thread1 = new Thread(() -> example.infiniteLoop()));
        thread1.start();

// 等待线程执行完毕，由于循环无界，无法强制退出
        try {
            thread1.join(); // 这里不会阻塞，因为线程已经进入无限循环状态
            System.out.println("Thread 1 join() failed!"); // 在实际运行中，这行代码将永远不会被执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
以上案例展示了Java多线程并发编程中的常见问题。在实际开发中，应充分理解和避免这些问题。