Java多线程并发问题实例

原创 Myth丶恋晨 2024-09-05 21:05 64阅读 0赞

在Java多线程并发编程中，常见的问题包括死锁、活锁、资源争抢、优先级反转等。

以下是一个简单的例子来展示这些问题：

1. 死锁：
```java
// 线程A持有资源1，等待资源2
class ThreadA extends Thread {
    Resource1 r1;
    Resource2 r2;

ThreadA(Resource1 r1, Resource2 r2) {
        this.r1 = r1;
        this.r2 = r2;
    }

public void run() {
        try {
            synchronized (r1) { // 线程A持有资源1
                synchronized (r2) { // 需要获取资源2，但是线程B可能已经持有
                    System.out.println("Thread A: Getting both resources...");
                    r2.acquire(); // 获取资源2
                    r1.notifyAll(); // 线程A持有资源1，通知等待的线程
                    return;
                }
            }

synchronized (r2) { // 从这里开始，我们可能会陷入活锁
                System.out.println("Thread A: Attempting to get resource2...");
                try {
                    r2.acquire(); // 获取资源2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return;
            }

} catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 线程B持有资源2，等待资源1
class ThreadB extends Thread {
    Resource2 r2;
    Resource1 r1;

ThreadB(Resource2 r2, Resource1 r1) {
        this.r2 = r2;
        this.r1 = r1;
    }

public void run() {
        try {
            synchronized (r2) { // 线程B持有资源2
                System.out.println("Thread B: Holding resource 2...");
                while (!r1.tryAcquire(100))) { // 等待资源1，但是线程A可能已经持有
                    System.out.println("Thread B: Resource 1 not available, retrying...");
                    Thread.sleep(500); // 暂停500毫秒，防止死循环
                }
                return;
            }

synchronized (r1) { // 从这里开始，我们可能会陷入活锁
                System.out.println("Thread B: Attempting to get resource 1...");
                try {
                    r1.acquire(); // 获取资源1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return;
            }

} catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，线程A持有资源1，等待资源2。同时，线程B持有资源2，等待资源1。

当线程B尝试获取资源1时，由于线程A可能已经持有资源1，导致线程B无法获取，从而陷入活锁状态。

这只是一个简单的并发问题示例，实际的多线程编程中可能会遇到更复杂的问题。