Java 线程池（fork/join） 阶乘

 

目录

 说明：

 代码段：

1、生成一个随机数

 2、利用随机数求阶乘

 3、使用ForkJoinPool 利用BigInteger求阶乘

 总结

---

 说明：

 一个简单利用ForkJoinPool的分段阶乘

 代码段：

1、生成一个随机数

使用种子产生随机数。要求输入一个整数做为种子，产生 10000（含）~11000（含）之间的随机整数，对于相同的种子，产生的随机数序列是固定的。

import java.util.Random;
import java.util.Scanner;

public class Ram {
	private static Scanner scanner;

	public static void main(String[] args) {
		scanner = new Scanner(System.in);
		long seed = scanner.nextLong();
		Random r = new Random(seed);
		/*
		 * 设a<b, 要产生一个[a,b)之间的随机数的公式为: 
		 * int value = a+random.nextInt(b-a);
		 */
		int value = 10000 + r.nextInt(1001);
		System.out.println("种子产生的结果 "+value);

	}
}

 2、利用随机数求阶乘

 参考例1，输入种子，然后产生 5（含）~10（含）之间的随机数。求阶乘。

import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;

public class RamJC {
	private static Scanner scanner;

	public static void main(String[] args) {
		scanner = new Scanner(System.in);
		long seed = scanner.nextLong();
		Random r = new Random(seed);
		int value = 5 + r.nextInt(6);
		BigInteger b = BigInteger.valueOf(value);
		System.out.println(b + "");
		BigInteger b3 = JieC(b);
		System.out.println(b3 + "");
	}

	private static BigInteger JieC(BigInteger b) {
		int x = b.intValue();
		int num = 1;
		for (int i = 2; i <= x; i++) {
			num = num * i;
		}
		BigInteger b2 = BigInteger.valueOf(num);
		return b2;
	}
}

 3、使用ForkJoinPool 利用BigInteger求阶乘

 输入整数做为种子，随机产生一个5000~6000之间的整数（含5000和6000) ，计算阶乘

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class Main {
	static public final int NUM = 100;
	private static Scanner scanner;

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		scanner = new Scanner(System.in);
		long seed = scanner.nextLong();
		Random r = new Random(seed);
		int value = 5000 + r.nextInt(1001);
		System.out.println(value + "");

		JieC jiec = new JieC(1, value, value);
		// 线程数默认Runtime.getRuntime().availableProcessors()
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		ForkJoinTask<BigInteger> future = forkJoinPool.submit(jiec);
		System.out.println("最终结果 " + future.get());
	}
}

class JieC extends RecursiveTask<BigInteger> {
	private int MAX;
	private int max;
	private int min;

	public JieC(int min, int max, int MAX) {
		this.min = min;
		this.max = max;
		this.MAX = MAX;
	}

	@Override
	protected BigInteger compute() {
		int threadHold = (int) Math.ceil(MAX * 1.0 / Main.NUM); // 每组所所拥有的数字个数
		BigInteger count = BigInteger.valueOf(1);
		if ((max - min) <= threadHold) { // 最后一组
			for (int i = min; i <= max; i++) { // 累乘
				BigInteger x = BigInteger.valueOf(i);
				count = count.multiply(x);
			}
			System.out.println("这里的count " + count);
		} else {
			List<JieC> listTasks = new ArrayList<JieC>();
			for (int i = 0; i < Math.ceil(max * 1.0 / threadHold); i++) { // 能分的组数
				int end = (i + 1) * threadHold;
				if (end >= max) {
					end = max;
				}
				int start = i * threadHold + 1;
				JieC jiec = new JieC(start, end, MAX);
				listTasks.add(jiec);
			}

			for (JieC jiec : listTasks) {
				jiec.fork();
			}
			for (JieC jiec : listTasks) {
				count = count.multiply(jiec.join());
			}

		}
		return count;
	}
}

 总结

例题三 用BigInteger，因为22的阶乘结果就超过long的表示范围了。

聪明的朋友可以试试输出这个阶乘的前100位。