Java 使用2个线程查找数组中连续整数的最大和

我想用两个线程查找数组中连续整数的最大和

这是一个非常简单的单线程

int maxSum = Integer.MIN_VALUE;
    public static void main(String[] args) {
        MaxSumSubArray maxSumSubArray = new MaxSumSubArray();
        maxSumSubArray.maxSum(new int[]{1, 2, 3, -12, 7, 9,3} , 0);
        System.out.println(maxSumSubArray.maxSum);
    }

    public int maxSum(int[] nums, int index){
        int maxSumForCurrentIndex = 0;
        if (index == nums.length - 1)
            maxSumForCurrentIndex = nums[index];
        else
            maxSumForCurrentIndex = Math.max(nums[index], nums[index] + maxSum(nums, index + 1));
        maxSum = Math.max(maxSum, maxSumForCurrentIndex);
        return maxSumForCurrentIndex;
    }

我可以创建两个线程，一个是偶数索引，另一个是奇数索引，然后将结果存储在MaxHeap中并获取第一个元素

有没有更好的方法来做到这一点

我已经试过做代码了。像这样的。但它没有给我正确的答案

public static void main(String[] args) throws InterruptedException {
        MaxSumSubArray maxSumSubArray = new MaxSumSubArray();
        int[] nums = {1, 2, 3, -12, 7, 9, 3};
        int[] answer = new int[nums.length];
        for(int i = 0;i<answer.length; i = i+1){
            MaxSum m1=new MaxSum(nums, 0);
            m1.start();
            m1.join();
            answer[i] = m1.answer;
        }

        for(int i = 1;i<answer.length; i = i+2){
            MaxSum m2=new MaxSum(nums, i);
            m2.start();
            m2.join();
            answer[i] = m2.answer;
        }
        System.out.println(Arrays.toString(answer));
        System.out.println(Arrays.stream(answer).max().getAsInt());
    }



class MaxSum extends Thread{
    int[] nums;
    int index;
    int answer;

    MaxSum(int[] nums, int index){
        this.nums = nums;
        this.index = index;
        this.answer = Integer.MIN_VALUE;
    }
    @Override
    public void run() {
        int maxSumForCurrentIndex = 0;
        if(index == nums.length - 1){
            maxSumForCurrentIndex = nums[index];
        } else {
            MaxSum m1 = new MaxSum(nums, index + 1);
            m1.start();
            try {
                m1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            answer = Math.max(nums[index], nums[index] + m1.answer);
            maxSumForCurrentIndex = answer;
        }

    }
}

publicstaticvoidmain（String[]args）抛出InterruptedException{
MaxSumSubArray MaxSumSubArray=新的MaxSumSubArray（）；
int[]nums={1,2,3，-12,7,9,3}；
int[]答案=新的int[nums.length]；
对于（int i=0；i您可以让一个线程从左向右移动，而另一个线程从右向左移动。当线程通过数组的中间并找到一个负数时，它们会断开。然后从两个结果中取max

在最坏的情况下，两个线程都将浏览整个阵列，因此您不会得到任何加速。另一方面，如果很大一部分数字为负数，这将使您获得高达2倍的加速（假设阵列足够大，运行两个单独的线程是有意义的）.
为什么要使用两个线程来完成此任务，而不是一个或十个？如果您知道要使用多少个线程，那么您可能也知道每个线程的用途。您能描述一下每个线程的用途吗？正如@AndrewF在上文中所建议的，这个问题有点过于宽泛。我想了解如何将上述代码更改为在多线程环境中运行我同意，没有必要只有两个线程，