Futures-Callable中所有线程是否共享静态数组？线程操作逻辑疑问

首先，你用Runtime.getRuntime().availableProcessors()获取线程数并创建固定线程池的逻辑本身是合理的——对于CPU密集型任务，这个线程数能最大化利用CPU资源；如果是IO密集型任务，你可以适当调大线程数，但这并不是你数组访问出错的原因。

你遇到的核心问题是共享静态数组的线程安全问题：静态数组属于类级别的共享资源，当多个线程同时对它的指定位置进行写操作时，会出现竞态条件（Race Condition），导致数据写入不完整或被覆盖，最终在任务完成后访问数组时得到错误值。

举个例子，假设两个线程同时修改数组的同一个位置：线程A正在将计算结果写入数组，还没完成时，线程B也开始写入，这就会导致最终数组里的值可能是两个线程中任意一个的，甚至是被破坏的中间值（虽然int类型的写入在JVM中是原子操作，但如果你的计算逻辑依赖其他共享状态，或者多个线程操作同一个位置的逻辑不是原子的，依然会出问题）。

解决办法 #

这里有几种可靠的方案来修复这个问题：

1. 使用线程安全的数组容器

Java提供了java.util.concurrent.atomic.AtomicIntegerArray类，它的所有写操作都是原子性的，不需要额外的同步机制就能保证线程安全。修改后的代码大概是这样：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicIntegerArray;

public class ThreadSafeArrayDemo {
    // 用AtomicIntegerArray替代普通静态数组
    private static AtomicIntegerArray resultArray = new AtomicIntegerArray(10);

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int threads = Runtime.getRuntime().availableProcessors();
        ExecutorService service = Executors.newFixedThreadPool(threads);
        
        List<Callable<Void>> tasks = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            final int index = i; // 注意要final或者有效final
            tasks.add(() -> {
                // 模拟你的计算逻辑
                int calculationResult = new Random().nextInt(100);
                // 原子性设置数组指定位置的值
                resultArray.set(index, calculationResult);
                return null;
            });
        }
        
        service.invokeAll(tasks);
        service.shutdown();
        
        // 安全访问数组
        System.out.println("数组第5位的值：" + resultArray.get(5));
    }
}

2. 对数组的写操作加同步锁

如果不想换用原子数组，你可以在每个线程修改数组时，用synchronized块锁定数组对象，保证同一时间只有一个线程能修改数组：

// 普通静态数组
private static int[] resultArray = new int[10];

// 在Callable的逻辑中添加同步块
tasks.add(() -> {
    int calculationResult = new Random().nextInt(100);
    synchronized (resultArray) {
        resultArray[index] = calculationResult;
    }
    return null;
});

这种方式简单直接，但如果线程数量多，可能会有一定的性能开销，因为所有写操作都要排队等待锁。

3. 让Callable返回结果，主线程统一填充数组

另一种思路是避免在线程中直接修改共享数组，而是让每个Callable计算完成后返回结果（包含要写入的数组索引和对应的值），最后由主线程收集所有结果并填充数组。这样完全避免了并发修改的问题：

public class ResultCollectionDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int threads = Runtime.getRuntime().availableProcessors();
        ExecutorService service = Executors.newFixedThreadPool(threads);
        
        List<Callable<int[]>> tasks = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            tasks.add(() -> {
                int calculationResult = new Random().nextInt(100);
                // 返回索引和结果的数组
                return new int[]{index, calculationResult};
            });
        }
        
        // 收集所有任务的Future结果
        List<Future<int[]>> futures = service.invokeAll(tasks);
        service.shutdown();
        
        // 主线程统一填充数组
        int[] resultArray = new int[10];
        for (Future<int[]> future : futures) {
            int[] res = future.get();
            resultArray[res[0]] = res[1];
        }
        
        System.out.println("数组第5位的值：" + resultArray[5]);
    }
}

总结 #

你的线程池创建逻辑是没问题的，出错的根源在于多线程并发修改共享静态数组的线程安全问题。选择上面任意一种方案都能解决你的问题，其中AtomicIntegerArray是最简洁高效的方式，而主线程统一收集结果的方式则完全避免了共享状态，适合更复杂的计算场景。

内容的提问来源于stack exchange，提问作者rsc