多线程竞态条件：Java并发案例

原创我就是我 2024-09-22 01:48 96阅读 0赞

竞态条件是多线程编程中一个常见的问题。简单来说，竞态条件是指多个线程同时访问和修改同一资源，导致的结果不可预期。

下面是一个Java并发中的竞态条件案例：

```java
// 假设我们有一个共享变量count
class Counter {
    int count = 0;

// 同步方法，确保对count的更新是原子的
    synchronized void increment() {
        count++;
    }

// 获取当前计数
    synchronized int getCount() {
        return count;
    }
}

// 多线程场景，两个线程分别增加和获取count
public class ConcurrentConditionExample {
    private Counter counter;

public ConcurrentConditionExample() {
        counter = new Counter();
    }

// 线程1：增加计数
    public void incrementCountThread1() {
        new Thread(() -> {
            try {
                // 使用synchronized关键字确保原子性
                counter.increment();
                System.out.println("Thread 1 incremented count: " + counter.getCount());
            } catch (Exception e) {
                e.printStackTrace();
            }
        })).start();
    }

// 线程2：获取计数
    public void getCountThread2() {
        new Thread(() -> {
            try {
                // 同理，使用synchronized关键字确保原子性
                int count = counter.getCount();
                System.out.println("Thread 2 got count: " + count);
            } catch (Exception e) {
                e.printStackTrace();
            }
        })).start();
    }

public static void main(String[] args) {
        ConcurrentConditionExample example = new ConcurrentConditionExample();
        Thread thread1 = new Thread(example::incrementCountThread1));
        Thread thread2 = new Thread(example::getCountThread2));

// 启动线程
        thread1.start();
        thread2.start();
    }
}
```

在这个例子中，当两个线程同时执行`counter.increment()`和`counter.getCount()`时，就可能会出现竞态条件。因此，我们在访问共享资源时，通常会使用同步机制（如`synchronized`关键字）来保证原子性和避免竞态条件。