以下是使用ForkJoinPool实现并行递归计算的完整解决方案，包含任务拆分、结果合并和性能优化：

import java.util.concurrent.*;

public class ParallelRecursiveCalculator extends RecursiveTask<Long> {

    private static final int THRESHOLD = 1000;

    private final int[] array;

    private final int start;

    private final int end;

    public ParallelRecursiveCalculator(int[] array, int start, int end) {

        this.array = array;

        this.start = start;

        this.end = end;

    }

    @Override

    protected Long compute() {

        if (end - start <= THRESHOLD) {

            return sequentialCompute();

        }

        int mid = (start + end) >>> 1;

        ParallelRecursiveCalculator left = new ParallelRecursiveCalculator(array, start, mid);

        ParallelRecursiveCalculator right = new ParallelRecursiveCalculator(array, mid, end);

        left.fork();

        Long rightResult = right.compute();

        Long leftResult = left.join();

        return leftResult + rightResult;

    }

    private Long sequentialCompute() {

        long sum = 0;

        for (int i = start; i < end; i++) {

            sum += array[i];

        }

        return sum;

    }

    public static void main(String[] args) {

        int[] data = new int[10_000_000];

        Arrays.fill(data, 1);

        ForkJoinPool pool = new ForkJoinPool();

        long result = pool.invoke(new ParallelRecursiveCalculator(data, 0, data.length));

        System.out.println("Result: " + result);

    }

}

 java.util.concurrent.*;

public class FibonacciTask extends RecursiveTask<Long> {

    private final int n;

    public FibonacciTask(int n) {

        this.n = n;

    }

    @Override

    protected Long compute() {

        if (n <= 10) {

            return sequentialFibonacci(n);

        }

        FibonacciTask f1 = new FibonacciTask(n - 1);

        FibonacciTask f2 = new FibonacciTask(n - 2);

        f1.fork();

        return f2.compute() + f1.join();

    }

    private long sequentialFibonacci(int n) {

        if (n <= 1) return n;

        return sequentialFibonacci(n - 1) + sequentialFibonacci(n - 2);

    }

    public static void main(String[] args) {

        ForkJoinPool pool = new ForkJoinPool();

        long result = pool.invoke(new FibonacciTask(30));

        System.out.println("Fibonacci(30) = " + result);

    }

}

代码说明：第一个示例展示数组求和的分治并行计算，第二个示例实现斐波那契数列的并行递归。两者都通过ForkJoinTask拆分任务，自动利用多核处理器资源。