一个有10000个元素的整型数组，数组中的每个元素是0-10000间的随机整数，计算数组中所有元素之和，要求用两个线程实现。用Java实现

为了在一个Java程序中使用两个线程同时计算一个包含10000个元素的整型数组的所有元素之和，我们可以利用`java.util.concurrent`包中的`ExecutorService`和`Callable`接口。这里是一个简单的示例：

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ArraySumWithThreads {
    private int[] array;
    private int totalSum = 0;

    public ArraySumWithThreads(int[] array) {
        this.array = array;
    }

    public void parallelSum() throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池

        // 将数组拆分成两部分
        int halfArraySize = array.length / 2;
        int[] part1 = Arrays.copyOfRange(array, 0, halfArraySize);
        int[] part2 = Arrays.copyOfRange(array, halfArraySize, array.length);

        // 使用Callable接口和Future获取结果
        Future<Integer> future1 = executor.submit(new SumTask(part1));
        Future<Integer> future2 = executor.submit(new SumTask(part2));

        // 合并结果
        totalSum += future1.get(); // 等待并获取第一个部分的和
        totalSum += future2.get(); // 等待并获取第二个部分的和

        executor.shutdown(); // 关闭线程池
    }

    private static class SumTask implements Callable<Integer> {
        private final int[] numbers;

        public SumTask(int[] numbers) {
            this.numbers = numbers;
        }

        @Override
        public Integer call() {
            return Arrays.stream(numbers).sum();
        }
    }

    public int getTotalSum() {
        return totalSum;
    }

    public static void main(String[] args) {
        int[] randomArray = new int[10000];
        for (int i = 0; i < randomArray.length; i++) {
            randomArray[i] = (int) (Math.random() * 10001); // 生成0-10000之间的随机整数
        }
        
        try {
            ArraySumWithThreads sumCalculator = new ArraySumWithThreads(randomArray);
            sumCalculator.parallelSum();
            System.out.println("Array sum in parallel: " + sumCalculator.getTotalSum());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们首先创建了一个线程池，并将数组分为两个部分。然后，我们提交一个任务来计算每个部分的和，最后合并这两个部分的和。注意，由于线程安全的问题，直接对`totalSum`变量进行累加可能会导致数据竞争，但在本例中我们假设`Arrays.stream()`已经进行了内部同步。