Java多线程并发控制不当导致的问题实例

原创港控/mmm° 2024-10-24 06:30 56阅读 0赞

在Java多线程编程中，如果并发控制不当，可能会出现以下问题实例：

1. 数据不一致：多个线程同时访问和修改同一数据，可能会导致数据错误。

例如：
```java
public class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
        notifyAll(); // 唤醒等待的线程
    }

public synchronized int getCount() {
        while (count == 0) { // 确保计数正确
            wait();
        }
        return count;
    }
}
```
2. 死锁：两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。

例如：
```java
public class DeadLockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void methodA() throws InterruptedException {
        synchronized (lock1) {
            System.out.println("Method A: Holding lock 1");
            lock2.lock(); // 请求锁2

while (!lock2.tryLock())) { // 如果不能立即获得锁，就等待
                System.out.println("Method A: Waiting for lock 2 to be unlocked");
                lock1.unlock(); // 释放锁1
                return;
            }
            System.out.println("Method A: Acquired both locks.");
        }
    }

public void methodB() throws InterruptedException {
        synchronized (lock2) {
            System.out.println("Method B: Holding lock 2");
            lock1.lock(); // 请求锁1

while (!lock1.tryLock())) { // 如果不能立即获得锁，就等待
                System.out.println("Method B: Waiting for lock 1 to be unlocked");
                lock2.unlock(); // 释放锁2
                return;
            }
            System.out.println("Method B: Acquired both locks.");
        }
    }

public static void main(String[] args) {
        DeadLockExample example = new DeadLockExample();
        example.methodA();
        example.methodB();
    }
}
```
以上实例中，`methodA()`持有`lock1`等待`lock2`释放，然后同样等待`lock1`释放。`methodB()`的逻辑类似。

这样的设计可能导致死锁，因为线程间的资源请求和释放顺序不满足死锁预防原则。