深入理解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() {
        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);
    }

    private static class MyThread implements Runnable {
        private int[] num; // 数组本身不是共享修改的目标
        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.TimeUnit;

class RaceConditionDemo implements Runnable {
    private int counter = 0; // 共享的计数器

    public void increment() {
        try {
            // 模拟耗时操作，增加线程切换的可能性
            TimeUnit.MILLISECONDS.sleep(10); 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }
        counter++; // 非原子操作
    }

    public void decrement() {
        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 counter = new RaceConditionDemo(); // 多个线程共享同一个RaceConditionDemo实例
        Thread t1 = new Thread(counter, "Thread-1");
        Thread t2 = new Thread(counter, "Thread-2");
        Thread t3 = new Thread(counter, "Thread-3");
        Thread t4 = new Thread(counter, "Thread-4");
        Thread t5 = new Thread(counter, "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