Java多线程中竞态条件的原理与实践

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SyncDemo1 {
    public static void main(String[] args) {
        new SyncDemo1().startThread();
    }

    private void startThread() {
        // 数组num在此处被初始化，但其元素在MyThread的run方法中并未被修改，仅用于构造器。
        int[] num = new int[1000]; 
        ExecutorService executor = Executors.newFixedThreadPool(5);
        MyThread thread1 = new MyThread(num, 1, 200);
        MyThread thread2 = new MyThread(num, 201, 400);
        MyThread thread3 = new MyThread(num, 401, 600);
        MyThread thread4 = new MyThread(num, 601, 800);
        MyThread thread5 = new MyThread(num, 801, 1000);

        executor.execute(thread1);
        executor.execute(thread2);
        executor.execute(thread3);
        executor.execute(thread4);
        executor.execute(thread5);
        executor.shutdown();

        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }

        // 各线程的局部和相加
        int totalSum = thread1.getSum() + thread2.getSum() + thread3.getSum() + thread4.getSum() + thread5.getSum();
        System.out.println(totalSum); // 结果总是500500
    }

    private static class MyThread implements Runnable {
        private int[] num; // 数组num在此处作为成员变量，但其元素在run方法中并未被修改。
        private int from, to, sum; // sum是每个MyThread实例的局部变量

        public MyThread(int[] num, int from, int to) {
            this.num = num;
            this.from = from;
            this.to = to;
            sum = 0;
        }

        public void run() {
            for (int i = from; i <= to; i++) {
                sum += i; // 每个线程修改的是自己的局部sum变量
            }
            // 模拟耗时操作，但由于sum是局部变量，不会导致竞态条件
            try {
                Thread.sleep(1000); 
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        public int getSum() {
            return this.sum;
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class RaceConditionDemo implements Runnable {
    private int counter = 0; // 共享的、可变的资源

    public void increment() {
        try {
            // 引入短暂延迟，增加线程上下文切换的可能性，从而更容易暴露竞态条件
            Thread.sleep(10); 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        counter++; // 非原子操作：读取-修改-写入
    }

    public void decrement() {
        counter--; // 非原子操作：读取-修改-写入
    }

    public int getValue() {
        return counter;
    }

    @Override
    public void run() {
        this.increment();
        System.out.println("线程 " + Thread.currentThread().getName() + " 增量后值: " + this.getValue());

        this.decrement();
        System.out.println("线程 " + Thread.currentThread().getName() + " 最终值: " + this.getValue());
    }

    public static void main(String args[]) {
        RaceConditionDemo counterInstance = new RaceConditionDemo(); // 共享同一个实例
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            executor.execute(new Thread(counterInstance, "Thread-" + (i + 1)));
        }

        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("所有线程执行完毕，最终计数器值: " + counterInstance.getValue());
    }
}

线程 Thread-3 增量后值: 5
线程 Thread-5 增量后值: 5
线程 Thread-1 增量后值: 5
线程 Thread-2 增量后值: 5
线程 Thread-4 增量后值: 5
线程 Thread-2 最终值: 1
线程 Thread-1 最终值: 2
线程 Thread-5 最终值: 3
线程 Thread-3 最终值: 4
线程 Thread-4 最终值: 0
所有线程执行完毕，最终计数器值: 0