executor 并发框架，实现 100阶乘分解为 10 个子任务运算

Jannabi

已于 2022-03-11 19:26:33 修改

阅读量630

点赞数 1

文章标签： java

于 2022-03-11 19:26:19 首次发布

本文链接：https://blog.csdn.net/Jannabi/article/details/123431960

版权

该博客介绍了如何使用Java的BigInteger类处理大整数的加减乘除和幂运算，并展示了如何在多线程环境中通过Callable和Future接口实现任务并行计算，最终累加计算100!的各个部分。代码示例中包含了一个SumTask类，实现了计算任务的Callable接口，以及一个SumTest类，用于启动线程池并监控任务进度，最终得出100!的总和。

摘要由CSDN通过智能技术生成

1.100！所得结果较长需要用BigInteger数据类型来储存结果

2.BigInteger运算语法 BigInteger t；

加法 t.add()

减法t.subtract()

乘法t.multiply()

除法t.divide()

幂运算 t.pow()

取余 t.remainder()

绝对值t.abs();

...

本文中用到的其他语法判断 BigInteger数据是否相等 t.compareTo() ，若小于值为-1，等于为0，大于为1.

源代码：

SumTask.java

import java.math.BigInteger;
import java.util.Random;
import java.util.concurrent.Callable;

public class SumTask implements Callable<BigInteger> {
    //定义每个线程计算的区间
    private BigInteger startNumber;
    private BigInteger endNumber;
    //上一次任务运算结果
    private BigInteger result;

    public SumTask(BigInteger startNumber, BigInteger endNumber,BigInteger result){
        this.startNumber=startNumber;
        this.endNumber=endNumber;
        this.result = result;
    }
    @Override
    public BigInteger call() throws Exception {
        BigInteger temp = new BigInteger("1");
        while(startNumber.compareTo(endNumber)!=1)
        {
            result = result.multiply(startNumber);
            startNumber = startNumber.add(temp);

        }
        Thread.sleep(new Random().nextInt(1000));

        System.out.printf("%s: %d\n",Thread.currentThread().getName(),result);
        return result;
    }
}

SumTest.java

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;


public class SumTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        BigInteger temp2;
        //用于存储上一次任务所得结果
        BigInteger temp1 = new BigInteger("1");
        //固定值
        BigInteger temp = new BigInteger("1");
        BigInteger end = new BigInteger("10");
        //将第几次循环的Int类型数据转换为String类型
        String temp4;
        // 执行线程池
        ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(10);

        List<Future<BigInteger>> resultList=new ArrayList<>();
        List<Future<BigInteger>> resultList1=new ArrayList<>();

        for (int i = 0;i<10;i++)
        {
            temp4 = String.valueOf(i);
            temp2 = new BigInteger(temp4);
            SumTask calculator = new SumTask(temp2.multiply(end).add(temp),temp2.add(temp).multiply(end),temp1);
            Future<BigInteger> result=executor.submit(calculator);
            resultList1.add(result);
            resultList.add(result);
            Future<BigInteger> result1 = resultList.get(i);
            temp1 = result1.get();
        }
        // 每隔50毫秒，轮询等待10个任务结束
        do {
            System.out.printf("Main: 已经完成多少个任务: %d\n",executor.getCompletedTaskCount());
            for (int j=0; j<resultList1.size(); j++) {
                Future<BigInteger> result=resultList1.get(j);
                System.out.printf("Main: Task %d: %s\n",j,result.isDone());
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } while (executor.getCompletedTaskCount()<resultList.size());

        // 所有任务都已经结束了，综合计算结果
        BigInteger total = new BigInteger("0");
        for (int j=0; j<resultList1.size(); j++) {
            Future<BigInteger> result=resultList1.get(j);
            BigInteger sum;
            try {
                sum=result.get();
                total = total.add(sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.printf("100!总和:" + total);

        // 关闭线程池
        executor.shutdown();
    }
}