这个JoinForkTask问题有解决方案吗？

如何解决这个JoinForkTask问题有解决方案吗？

此代码将数组的元素乘以给定的数字，如果数组长度> THRESHOLD，则该代码将数组分成100个小数组，并使用RecurciveAction进行处理。但是我不知道为什么它没有显示任何结果。 PS。如果数组长度

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveAction;
import java.util.stream.IntStream;

public class ArrayTransform extends RecursiveAction {

    
    
    private int arr[];
    private final int THRESHOLD =100;

    

    private int multiplyBy;

    public ArrayTransform(int arr[],int multiplyBy) {
        this.multiplyBy = multiplyBy;
        this.arr = arr;
    }

    private List<ArrayTransform> tasks() {
        List<ArrayTransform> tasks = new ArrayList<>(arr.length / 100);
        // BREAKING the array into 100 arrays
        int breakpoint = 99;
        for (int i = 0; i < arr.length / 100; i++) {
            if (tasks.isEmpty() ) {
                tasks.add(i,new ArrayTransform(Arrays.copyOfRange(arr,99),multiplyBy));

            } else {

                tasks.add(i,breakpoint+1,breakpoint + 100),multiplyBy));
                breakpoint += 100;
            }
        }
        
        return tasks;
    }

    private void multiply(int arr[]) {
        for (int i = 0; i < arr.length; i++)
            arr[i] = arr[i] * multiplyBy;
    }

    @Override
    protected void compute() {
        if (arr.length < THRESHOLD) {
            multiply(arr);

        } else {

            ForkJoinTask.invokeAll(tasks());
        }
    }

    public static void main(String args[]) {
        int test[] = IntStream.rangeClosed(1,10000).toArray();
        System.out.println("original array :"+Arrays.toString(test));
        ForkJoinPool common = ForkJoinPool.commonPool();

        common.invoke(new ArrayTransform(test,2));
        System.out.println("after transformation :"+Arrays.toString(test));
    
    }
}

解决方法

您可以在main方法中生成一个数组，并将其传递给您的类并检查原始数组。

您的方法tasks()执行拆分并将原始数组数据复制到新数组中，这些新数组由新的ArrayTransform对象私有保存。修改后的数据永远不会传输回原始数组。