理解并避免Java多线程并发问题示例

原创绝地灬酷狼 2024-10-08 05:15 91阅读 0赞

Java多线程并发问题是由于多个线程同时执行，可能会出现资源争抢、死锁等问题。以下是一个简单的示例来理解这些问题：

1. **资源争抢**：
```java
class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
        }
        return count;
    }

public int getCount() {
        return count;
    }
}

public class ResourceRaceExample {
    private Counter counter = new Counter();

public void incrementCounter() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

public void printCounters() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Counter " + i + ": " + counter.decrement());
        }
    }

public static void main(String[] args) {
        ResourceRaceExample example = new ResourceRaceExample();
        example.incrementCounter();
        example.printCounters();
    }
}
```
在这个例子中，多个线程同时执行`incrementCounter()`方法，导致`counter.increment()`操作可能被多次覆盖，最终结果不准确。

2. **死锁**：
```java
class DeadlockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void acquireLock1() {
        synchronized (lock1) {
            System.out.println("Acquiring Lock 1");
        }
    }

public void acquireLock2() {
        synchronized (lock2) {
            System.out.println("Acquiring Lock 2");
        }
    }

public void deadlockExample() throws InterruptedException {
        Thread thread1 = new Thread(() -> acquireLock1()));
        Thread thread2 = new Thread(() -> acquireLock2()));

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

// 等待线程执行完毕
        thread1.join();
        thread2.join();

System.out.println("Deadlock detected!");
    }
}

public class Main {
    public static void main(String[] args) {
        DeadlockExample deadlockExample = new DeadlockExample();
        deadlockExample.deadlockExample();
    }
}
```
在这个例子中，两个线程`thread1`和`thread2`试图同时获取锁1和锁2。如果一个线程等待另一个线程释放锁，就可能导致死锁。

要避免这些并发问题，通常会采取以下策略：

- **使用锁（ synchronized ）**：在访问共享资源的地方加锁，确保同一时间只有一个线程访问该资源。
- **避免嵌套锁**：一个线程尽量只获取它需要的锁，以减少死锁的可能性。
- **超时重试机制**：如果一个线程长时间无法获取锁，可以设置超时时间并重新尝试，从而降低因等待过久而导致的问题。