如何在 Java Fork-Join 多线程程序中合并数组？

Question

我构建了一个中值过滤器，基本上它的作用是抓取一个元素数组，过滤它并返回一个过滤后的数组。现在，顺序版本可以完美运行，但是在尝试制作 Fork-Join 版本时，我无法获得大于我的顺序阈值的数组的任何结果，并且还伴随着 ArrayIndexOutOfBounds 错误。

现在，我不确定自己哪里出了问题，经过数小时围绕 Google 和 S.O 的研究后，我放弃并决定在这里发布问题。

这是我按顺序进行过滤的代码 sn-p：

//Filter Algorithm.
    private void filter(BigDecimal[] elements, int shoulder) {
        //Add boundary values in beginning
        for(int i=0; i<shoulder; i++){
            filteredElements[i] = elements[i];
        }

        //Add boundary values at end
        for(int i=arraySize-1; i>((arraySize-1) - shoulder); i--){
            filteredElements[i] = elements[i];
        }

        //Add middle values to filteredElements array
        for (int i = shoulder; i < elements.length-shoulder; i++) {
            BigDecimal[] windowValue = prepareWindow(elements, shoulder, filterSize);
            BigDecimal median = getMedian(windowValue);
            filteredElements[i] = median;
        }
    }


    /*
     * Pre-condition: Get Windowed Array
     * Post-Condition: Return Median
     */
    private static BigDecimal getMedian(BigDecimal[] windowValue) {
        Arrays.sort(windowValue);
        return windowValue[(filterSize-1)/2];
    }


    /*
     * Pre-condition: Get elements array, get shoulder value and length of filterSize. Notice that this is given name windowLength.
     * Post-Condition: Return Windowed Array
     */
    private static BigDecimal[] prepareWindow(BigDecimal[] elements, int shoulder, int windowLength) {
        BigDecimal[] out = new BigDecimal[windowLength];
        int outCounter = 0;
        for(int i = position; i<position+filterSize; i++){
            out[outCounter] = elements[i];
            outCounter++;
        }
        position++;
        return out;
    }


    //Return Filtered Array
    public BigDecimal[] getFilteredArray(){
        return filteredElements;
    }

现在，如果数组大于顺序阈值，则在 Fork-Join 中应用的相同顺序代码不起作用，我想知道我在哪里出错了。

这是我的 Parallel 实现的 sn-p：

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.concurrent.RecursiveTask;

public class Parallel extends RecursiveTask<BigDecimal[]>{
    BigDecimal[] elements;
    BigDecimal[] filteredElements; //Array that contains the filtered elements
    int shoulder;
    static int filterSize;  
    int begin;
    int end;
    static int position = 0;
    static final int SEQUENTIAL_CUTOFF = 4;


    public Parallel(BigDecimal[] elements, int filterSize, int begin, int end) {
        this.elements = elements;
        Parallel.filterSize = filterSize;
        this.begin = begin;
        this.end = end;
        filteredElements = new BigDecimal[elements.length]; //Array that contains the filtered elements
        shoulder = (filterSize - 1) / 2;
    }

    @Override
    protected BigDecimal[] compute() {

        if (end - begin <= SEQUENTIAL_CUTOFF) {                         
            filter(elements, shoulder); //Run Filter Method
        }else{
            Parallel curLeft = new Parallel(elements, filterSize, this.begin, ((this.begin+this.end)/2));
            Parallel curRight = new Parallel(elements, filterSize, ((this.begin+this.end)/2), this.end);
            curLeft.fork();
            curRight.compute();
            curLeft.join();

        }
        return filteredElements;
    }

    //Filter Algorithm.
        private void filter(BigDecimal[] elements, int shoulder) {          
            //Add boundary values in beginning
            for(int i=0; i<shoulder; i++){
                filteredElements[i] = elements[i];
            }

            //Add boundary values at end
            for(int i=this.elements.length-1; i>((this.elements.length-1) - shoulder); i--){
                filteredElements[i] = elements[i];
            }

            //Add middle values to filteredElements array
            for (int i = shoulder; i < elements.length-shoulder; i++) {
                BigDecimal[] windowValue = prepareWindow(elements, shoulder, filterSize);
                BigDecimal median = getMedian(windowValue);
                filteredElements[i] = median;
            }
        }


        /*
         * Pre-condition: Get Windowed Array
         * Post-Condition: Return Median
         */
        private static BigDecimal getMedian(BigDecimal[] windowValue) {
            Arrays.sort(windowValue);
            return windowValue[(filterSize-1)/2];
        }   


        /*
         * Pre-condition: Get elements array, get shoulder value and length of filterSize. Notice that this is given name windowLength.
         * Post-Condition: Return Windowed Array
         */
        private static BigDecimal[] prepareWindow(BigDecimal[] elements, int shoulder, int windowLength) {
            BigDecimal[] out = new BigDecimal[windowLength];
            int outCounter = 0;
            for(int i = position; i<position+filterSize; i++){
                out[outCounter] = elements[i];
                outCounter++;
            }
            position++;
            return out;
        }

      //Return Filtered Array
        public BigDecimal[] getFilteredArray(){
            return filteredElements;
        }

}

基本上 Parallel 实现使用我制作的顺序方法，但我无法让它工作。下面是我遇到的错误列表（我添加了导致错误的行以使阅读更容易。大多数错误都在顺序方法中，我不明白为什么）：

Caused by: java.lang.ArrayIndexOutOfBoundsException: 8
    at Parallel.prepareWindow(Parallel.java:80)  > out[outCounter] = elements[i];
    at Parallel.filter(Parallel.java:55) > BigDecimal[] windowValue = prepareWindow(elements, shoulder, filterSize);
    at Parallel.compute(Parallel.java:29) > filter(elements, shoulder); //Run Filter Method
    at Parallel.compute(Parallel.java:34) > curRight.compute();

如果有人能提供有意义的答案，将不胜感激。

谢谢。

Answer 1

我们看不到整个代码，但我看到不知何故，两个 compute() 被并行调用，它们同时调用 prepareWindow()。

最大的问题是position 是一个静态变量，两个线程都在递增相同的引用，将其推出边界。