Java中的并发问题：线程竞态条件示例

原创阳光穿透心脏的1/2处 2024-12-09 02:42 21阅读 0赞

线程竞态条件是指多个线程同时访问和修改共享资源，从而导致结果的不可预测性。以下是一个简单的Java线程竞态条件示例：

```java
// 创建一个全局变量，作为共享资源
public class SharedResource {
    private int count = 0;

// 提供获取当前计数的方法
    public synchronized int getCount() {
        return count;
    }

// 提供增加计数的方法
    public synchronized void incrementCount() {
        count++;
    }
}

// 创建两个线程，共享同一个资源
public class ThreadRaceExample {

private SharedResource sharedResource;

public ThreadRaceExample(SharedResource sharedResource) {
        this.sharedResource = sharedResource;
    }

// 线程1：增加计数
    public class Thread1 extends Thread {

@Override
        public void run() {
            try {
                for (int i = 0; i < 1000; i++) {
                    sharedResource.incrementCount();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

// 线程2：获取并打印计数
    public class Thread2 extends Thread {

@Override
        public void run() {
            try {
                for (int i = 0; i < 1000; i++) {
                    int countBeforeGet = sharedResource.getCount();
                    sharedResource.incrementCount();
                    int countAfterGet = sharedResource.getCount();

System.out.println("Thread2 - Iteration " + i +
                        ": Before get: " + countBeforeGet +
                        ", After get: " + countAfterGet);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

public static void main(String[] args) throws InterruptedException {

// 创建共享资源对象
        SharedResource sharedResource = new SharedResource();

// 启动两个线程
        Thread1 thread1 = new Thread1(sharedResource);
        Thread2 thread2 = new Thread2(sharedResource);

// 线程启动后等待执行完成
        thread1.start();
        thread2.start();
        thread1.join(); // 等待线程1执行完成
        thread2.join(); // 等待线程2执行完成

}
}
```

这个示例中，`Thread1`线程不断增加共享资源的计数，而`Thread2`线程则在每次循环获取并打印计数。

由于两个线程同时访问和修改共享资源，就可能发生竞态条件。在这个例子中，如果`Thread1`比`Thread2`先完成所有循环，那么最终的计数可能不正确。