如何并行化Java阶乘代码以提升百万级数值计算效率？

要并行化阶乘计算，核心思路是利用乘法的结合律——把1到n的数字拆分成多个独立区间，每个区间单独计算乘积，最后把所有区间的结果相乘就行。因为每个区间的计算互不依赖，完全可以并行执行，从而利用多核CPU的性能优势。

Java里的Fork/Join框架专门处理这种分治类型的并行任务，适合新手快速实现并行逻辑，不用手动管理线程。下面是修改后的代码：

package programas;

import java.math.BigInteger;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class IterativeFactorial {

    // 并行任务类：负责计算指定区间内的乘积
    private static class FactorialTask extends RecursiveTask<BigInteger> {
        private final BigInteger start;
        private final BigInteger end;
        // 阈值：区间大小小于等于这个值时，改用串行计算（避免线程开销）
        private static final BigInteger THRESHOLD = BigInteger.valueOf(1000);

        public FactorialTask(BigInteger start, BigInteger end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected BigInteger compute() {
            BigInteger range = end.subtract(start).add(BigInteger.ONE);
            // 区间过小，串行计算更高效
            if (range.compareTo(THRESHOLD) <= 0) {
                BigInteger product = BigInteger.ONE;
                for (BigInteger i = start; i.compareTo(end) <= 0; i = i.add(BigInteger.ONE)) {
                    product = product.multiply(i);
                }
                return product;
            } else {
                // 拆分区间为左右两部分
                BigInteger mid = start.add(range.divide(BigInteger.TWO));
                FactorialTask leftTask = new FactorialTask(start, mid);
                FactorialTask rightTask = new FactorialTask(mid.add(BigInteger.ONE), end);
                
                // 异步执行左任务，当前线程执行右任务
                leftTask.fork();
                BigInteger rightResult = rightTask.compute();
                // 等待左任务完成并获取结果
                BigInteger leftResult = leftTask.join();
                
                // 合并两个区间的乘积
                return leftResult.multiply(rightResult);
            }
        }
    }

    // 并行版阶乘方法
    public BigInteger parallelFactorial(BigInteger n) {
        if (n == null) {
            throw new IllegalArgumentException();
        }
        if (n.signum() == -1) {
            throw new IllegalArgumentException("Argument must be a non-negative integer");
        }
        if (n.equals(BigInteger.ZERO) || n.equals(BigInteger.ONE)) {
            return BigInteger.ONE;
        }
        // 创建ForkJoin线程池，默认根据CPU核心数分配线程
        ForkJoinPool pool = new ForkJoinPool();
        try {
            return pool.invoke(new FactorialTask(BigInteger.ONE, n));
        } finally {
            pool.shutdown();
        }
    }

    // 原串行版阶乘方法（保留对比用）
    public BigInteger factorial(BigInteger n) {
        if ( n == null ) {
            throw new IllegalArgumentException();
        }
        else if ( n.signum() == - 1 ) {
            throw new IllegalArgumentException("Argument must be a non-negative integer");
        }
        else {
            BigInteger factorial = BigInteger.ONE;
            for ( BigInteger i = BigInteger.ONE; i.compareTo(n) < 1; i = i.add(BigInteger.ONE) ) {
                factorial = factorial.multiply(i);
            }
            return factorial;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        BigInteger number, result;
        boolean error = false;
        System.out.println("FACTORIAL OF A NUMBER");
        do {
            System.out.println("Enter a number:");
            try {
                number = scanner.nextBigInteger();
                // 调用并行版方法
                result = new IterativeFactorial().parallelFactorial(number);
                error = false;
                System.out.println("Factorial of " + number + ": " + result);
            }
            catch ( InputMismatchException e ) {
                error = true;
                scanner.nextLine();
            }
            catch ( IllegalArgumentException e ) {
                error = true;
                scanner.nextLine();
                System.out.println(e.getMessage());
            }
        }
        while ( error );
        scanner.close();
    }
}

关键细节说明 #

• 阈值调整：THRESHOLD的值可以根据你的机器配置调整（比如改成2000或5000）。如果阈值太小，线程创建和切换的开销会抵消并行收益；阈值太大，又无法充分利用多核性能。
• Fork/Join逻辑：fork()会把任务提交到线程池异步执行，compute()让当前线程直接执行任务，join()等待异步任务完成并获取结果，框架会自动平衡线程负载。
• 线程安全：BigInteger是不可变类，多个线程计算各自区间的乘积时不会出现线程安全问题，最后合并结果只是简单的乘法操作。

对于100万级别的输入，并行版能显著提升速度——比如4核CPU理论上能达到接近4倍的性能提升（实际会因线程开销略有折扣）。

内容的提问来源于stack exchange，提问作者Rodrigo