Java多线程与并发编程：编写一个测试程序，利用 executor 并发框架，实现 100的阶乘分解为 10 个子任务运算。

编写一个测试程序，利用 executor 并发框架，实现 100!分解为 10 个子任务运算。

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

public class SumTask implements Callable<BigInteger> {
	//定义每个线程计算的区间
	private int startNumber;
	private int endNumber;
	
	public SumTask(int startNumber, int endNumber){
		this.startNumber=startNumber;
		this.endNumber=endNumber;
	}
	
	@Override
	public BigInteger call() throws Exception {
		long sum=1;
		for(int i=startNumber; i<=endNumber; i++)
		{
			
			sum = sum*i;			
		}
		
		Thread.sleep(new Random().nextInt(1000));
		
		BigInteger BigSUM=new BigInteger(String.valueOf(sum));
		
		System.out.printf("%s: %d\n",Thread.currentThread().getName(),BigSUM);
		return BigSUM;
	}
}

//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) {
		
		// 执行线程池
		ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(4);
		
		List<Future<BigInteger>> resultList=new ArrayList<>();

		//统计100!总和，分成10个任务计算，提交任务
		for (int i=0; i<10; i++){
			SumTask calculator=new SumTask(i*10+1, (i+1)*10);
			Future<BigInteger> result= executor.submit(calculator);
			resultList.add(result);
		}
		
		// 每隔50毫秒，轮询等待10个任务结束
		do {
			System.out.printf("Main: 已经完成多少个任务: %d\n",executor.getCompletedTaskCount());
			for (int i=0; i<resultList.size(); i++) {
				Future<BigInteger> result=resultList.get(i);
				System.out.printf("Main: Task %d: %s\n",i,result.isDone());
			}
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} while (executor.getCompletedTaskCount()<resultList.size());
		
		// 所有任务都已经结束了，综合计算结果		
		BigInteger total = new BigInteger(String.valueOf(1));
		for (int i=0; i<resultList.size(); i++) {
			Future<BigInteger> result=resultList.get(i);
			BigInteger sum=new BigInteger(String.valueOf(0));
			try {
				sum=result.get();
				total = total.multiply(sum);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		System.out.printf("100!:" + total);
		
		// 关闭线程池
		executor.shutdown();
	}
}