Java多线程竞态条件：理解与实验演示

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

    private void startThread() {
        // ... (省略部分初始化代码) ...
        ExecutorService executor = Executors.newFixedThreadPool(5);
        MyThread thread1 = new MyThread(num, 1, 200);
        MyThread thread2 = new MyThread(num, 201, 400);
        // ... (其他线程初始化) ...
        executor.execute(thread1);
        executor.execute(thread2);
        // ... (其他线程执行) ...
        executor.shutdown();
        while (!executor.isTerminated()) { } // 等待所有任务完成

        // 汇总各个线程的局部和
        int totalSum = thread1.getSum() + thread2.getSum() + thread3.getSum() + thread4.getSum() + thread5.getSum();
        System.out.println(totalSum);
    }

    private static class MyThread implements Runnable {
        private int[] num;
        private int from, to, sum; // 每个线程拥有独立的sum变量

        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变量
            }
            // pause(); // 原始代码中的暂停操作，对竞态条件无直接影响
        }

        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) {
            e.printStackTrace();
        }
        counter++; // 非原子操作：读取 counter，递增，写回 counter
    }

    public void decrement() {
        counter--; // 非原子操作：读取 counter，递减，写回 counter
    }

    public int getValue() {
        return counter;
    }

    @Override
    public void run() {
        this.increment();
        System.out.println("Value for Thread After increment "
                + Thread.currentThread().getName() + " " + this.getValue());

        this.decrement();
        System.out.println("Value for Thread at last "
                + Thread.currentThread().getName() + " " + this.getValue());
    }

    public static void main(String args[]) {
        RaceConditionDemo sharedCounter = new RaceConditionDemo(); // 共享同一个实例
        Thread t1 = new Thread(sharedCounter, "Thread-1");
        Thread t2 = new Thread(sharedCounter, "Thread-2");
        Thread t3 = new Thread(sharedCounter, "Thread-3");
        Thread t4 = new Thread(sharedCounter, "Thread-4");
        Thread t5 = new Thread(sharedCounter, "Thread-5");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

Value for Thread After increment Thread-3 5
Value for Thread After increment Thread-5 5
Value for Thread After increment Thread-1 5
Value for Thread After increment Thread-2 5
Value for Thread at last Thread-2 1
Value for Thread After increment Thread-4 5
Value for Thread at last Thread-1 2
Value for Thread at last Thread-5 3
Value for Thread at last Thread-3 4
Value for Thread at last Thread-4 0