深入理解Java Future与并发共享状态管理：避免常见陷阱

List<Future<Integer>> elements = new ArrayList<>();
// ... 初始化 elements
// 尝试修改元素值，但类型不匹配
if (elements.get(firstIndex).get() - randomAmount > 0) {
    // 编译错误：set(int, Future<Integer>) cannot be applied to (int, int)
    elements.set(firstIndex, elements.get(firstIndex).get() - randomAmount);
}

var ex = Executors.newFixedThreadPool(10);
List<Integer> elements = new ArrayList<>(); // 直接存储整数
for (int i = 0; i < 100; i++) {
    elements.add(1000); // 初始化为1000
}

// 计算初始和
int sum = 0;
for (int el : elements) {
    sum += el;
}
System.out.println("Initial sum: " + sum);

// 提交任务进行并发修改
for (int i = 0; i < 10_000; i++) {
    ex.submit(() -> {
        int firstIndex = ThreadLocalRandom.current().nextInt(100);
        int secondIndex = ThreadLocalRandom.current().nextInt(100); // secondIndex在此逻辑中未使用
        int randomAmount = ThreadLocalRandom.current().nextInt(1000);

        // 注意：ArrayList在并发修改下非线程安全
        // 这里的get/set操作可能导致数据不一致或运行时错误
        if (elements.get(firstIndex) - randomAmount > 0) {
            elements.set(firstIndex, elements.get(firstIndex) - randomAmount);
        }
    });
}
// ... 后续需要关闭ExecutorService

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicIntegerArray;

public class ConcurrentArrayUpdate {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService ex = Executors.newFixedThreadPool(10);

        // 使用AtomicIntegerArray来安全地存储和修改整数
        AtomicIntegerArray elements = new AtomicIntegerArray(100);
        for (int i = 0; i < 100; i++) {
            elements.set(i, 1000); // 初始化每个元素为1000
        }

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

        // 提交10,000个任务进行并发修改
        for (int i = 0; i < 10_000; i++) {
            ex.submit(() -> {
                int firstIndex = ThreadLocalRandom.current().nextInt(100);
                // int secondIndex = ThreadLocalRandom.current().nextInt(100); // 在此逻辑中未使用
                int randomAmount = ThreadLocalRandom.current().nextInt(1000);

                // 原子性地检查并更新值
                // 使用compareAndSet或循环结合get/set来确保原子性操作
                while (true) {
                    int currentValue = elements.get(firstIndex);
                    if (currentValue - randomAmount > 0) {
                        // 尝试原子性地更新值
                        if (elements.compareAndSet(firstIndex, currentValue, currentValue - randomAmount)) {
                            break; // 更新成功，退出循环
                        }
                    } else {
                        break; // 条件不满足，无需更新，退出循环
                    }
                }
            });
        }

        // 关闭ExecutorService
        ex.shutdown();
        // 等待所有任务完成，最多等待1分钟
        if (!ex.awaitTermination(1, TimeUnit.MINUTES)) {
            System.err.println("ExecutorService did not terminate in the specified time.");
        }

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