并发问题再现：Java多线程竞态条件实例分析

原创今天药忘吃喽~ 2024-12-04 23:12 25阅读 0赞

并发问题在多线程编程中常常出现，尤其是竞态条件（Race Condition）是其中的一种常见现象。下面我们将通过几个典型的Java多线程竞态条件实例进行分析。

1. **共享变量修改**：
```java
class Counter {
    int count;

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

public class RaceConditionExample {
    private final Counter counter = new Counter();

public void threadA() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
            // 省略可能存在的其他同步代码
        }
    }

public void threadB() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
            // 省略可能存在的其他同步代码
        }
    }

public static void main(String[] args) {
        RaceConditionExample example = new RaceConditionExample();
        Thread threadA = new Thread(example::threadA);
        Thread threadB = new Thread(example::threadB);
        threadA.start();
        threadB.start();
        // 等待线程结束
        threadA.join();
        threadB.join();
    }
}
```
在这个例子中，`counter`是一个共享变量。如果两个线程同时访问这个变量并修改其值，就可能会发生竞态条件。

2. **锁的使用不当**：
```java
class ExclusiveResource {
    private boolean locked;

public synchronized void lock() {
        if (locked) {
            throw new IllegalStateException("Resource already locked!");
        }
        locked = true;
    }

public synchronized void unlock() {
        locked = false;
    }
}

public class RaceConditionExampleWithLock {
    private final ExclusiveResource resource = new ExclusiveResource();

public void threadA() {
        try {
            resource.lock();
            // 执行相关操作
            // ...
            resource.unlock();
        } catch (Exception e) {
            System.out.println("Thread A failed: " + e.getMessage());
        }
    }

public void threadB() {
        try {
            resource.lock();
            // 执行相关操作
            // ...
            resource.unlock();
        } catch (Exception e) {
            System.out.println("Thread B failed: " + e.getMessage());
        }
    }

public static void main(String[] args) {
        RaceConditionExampleWithLock example = new RaceConditionExampleWithLock();
        Thread threadA = new Thread(example::threadA));
        Thread threadB = new Thread(example::threadB));
        threadA.start();
        threadB.start();
        // 等待线程结束
        threadA.join();
        threadB.join();
    }
}
```
在这个例子中，`ExclusiveResource`是一个锁住资源的类。如果两个线程同时尝试获取这个锁，就可能会发生竞态条件。

总结：理解并发问题中的竞态条件，需要深入理解多线程、锁机制以及Java内存模型（JMM）。