使用Java频繁遇到的并发问题案例

原创爱被打了一巴掌 2024-11-26 06:00 17阅读 0赞

在Java编程中，常见的并发问题包括死锁、活锁、饥饿现象、资源泄露等。以下是一些具体的案例：

1. 死锁：
```java
// 示例代码，两个线程互相等待对方释放资源
class Resource {
    int count = 0;
    Object lock = new Object();

synchronized void give() {
        count--;
        notifyAll();
    }

synchronized void take() throws InterruptedException {
        while (count == 0) {
            wait(lock);
        }
        count++;
        notifyAll();
    }
}

class ThreadA extends Thread {
    private Resource res;

public ThreadA(Resource res) {
        this.res = res;
    }

@Override
    public void run() {
        try {
            res.take(); // 线程A等待线程B释放资源
            System.out.println("Thread A done");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    private Resource res;

public ThreadB(Resource res) {
        this.res = res;
    }

@Override
    public void run() {
        try {
            res.give(); // 线程B释放资源
            System.out.println("Thread B done");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource res = new Resource();
        ThreadA threadA = new ThreadA(res);
        ThreadB threadB = new ThreadB(res);

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

try {
            threadA.join();
            threadB.join();
            System.out.println("All threads done");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
这个例子中，线程A等待线程B释放资源，线程B则释放资源。如果两个线程按照这种方式交替操作，就可能会出现死锁。

2. 活锁：
```java
// 示例代码，多个线程互相等待对方释放资源，从而陷入无限循环的活锁状态
class Resource {
    int count = 0;
    Object lock = new Object();

synchronized void give() {
        count--;
        notifyAll();
    }

// 这里可以简化为一个空方法，目的是让调用这个资源的线程等待释放资源
    // 在实际应用中，可以将具体的业务逻辑放在这里，以模拟真实场景中的活锁问题
    // synchronized void doSomething() {
    //     // 这里可以放置需要执行的业务逻辑
    // }
}
```
在这个例子中，多个线程同时请求使用同一个资源，而这个资源只有在释放之前才会被其他线程访问。这种情况下，线程会陷入一个无限循环的状态，也就是活锁。