Java并发编程：掌握Future、线程安全与原子操作

List<Future<Integer>> elements = new ArrayList<>();
// ...
elements.set(firstIndex, elements.get(firstIndex).get() - randomAmount);

// ... 初始化 elements 列表后
ex.shutdown(); // 过早关闭 ExecutorService
// ... 之后尝试提交新的更新任务

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.ThreadLocalRandom;

public class ConcurrentArrayUpdateTutorial {

    public static void main(String[] args) throws InterruptedException {
        // 1. 初始化 ExecutorService，用于管理并发任务
        var ex = Executors.newFixedThreadPool(10);

        // 2. 使用 AtomicIntegerArray 存储可变整数，提供线程安全
        // AtomicIntegerArray 内部管理一个 int[]，并为每个元素提供原子操作
        AtomicIntegerArray elements = new AtomicIntegerArray(100);
        for (int i = 0; i < 100; i++) {
            elements.set(i, 1000); // 初始化每个元素为1000
        }

        // 计算初始总和
        int initialSum = 0;
        for (int i = 0; i < elements.length(); i++) {
            initialSum += elements.get(i);
        }
        System.out.println("Initial sum: " + initialSum);

        // 3. 提交大量并发更新任务
        int numberOfUpdates = 10_000;
        // 使用 CountDownLatch 等待所有更新任务完成
        CountDownLatch latch = new CountDownLatch(numberOfUpdates);

        for (int i = 0; i < numberOfUpdates; i++) {
            ex.submit(() -> {
                try {
                    int firstIndex = ThreadLocalRandom.current().nextInt(100);
                    // int secondIndex = ThreadLocalRandom.current().nextInt(100); // 原始问题中提及，但在逻辑中未被使用

                    int randomAmount = ThreadLocalRandom.current().nextInt(1000);

                    // 确保减法操作的原子性及条件判断
                    boolean updated = false;
                    while (!updated) {
                        int currentValue = elements.get(firstIndex); // 原子性获取当前值

                        // 检查是否有足够的量可以减去
                        if (currentValue >= randomAmount) {
                            // 使用 compareAndSet 尝试原子性地更新
                            // 如果 currentValue 在此期间被其他线程修改，compareAndSet 会失败，
                            // 循环会再次执行，获取新的 currentValue 并重试。
                            if (elements.compareAndSet(firstIndex, currentValue, currentValue - randomAmount)) {
                                updated = true; // 更新成功，退出循环
                                // 如果需要将 randomAmount 加到 secondIndex，可以在这里进行原子操作
                                // elements.getAndAdd(secondIndex, randomAmount);
                            }
                        } else {
                            // 当前值不足以减去 randomAmount，放弃本次更新
                            updated = true; // 退出循环
                        }
                    }
                } finally {
                    latch.countDown(); // 任务完成，计数器减一
                }
            });
        }

        // 4. 等待所有任务完成
        latch.await(); // 阻塞当前线程，直到所有任务都调用了 countDown()
        ex.shutdown(); // 提交所有任务后，关闭 ExecutorService
        // 等待 ExecutorService 中的所有任务真正终止
        if (!ex.awaitTermination(5, TimeUnit.SECONDS)) {
            System.err.println("Executor did not terminate in time. Forcing shutdown.");
            ex.shutdownNow(); // 如果超时，则强制关闭
        }

        // 5. 计算最终总和
        int finalSum = 0;
        for (int i = 0; i < elements.length(); i++) {
            finalSum += elements.get(i);
        }
        System.out.println("Final sum: " + finalSum);
    }
}