判断100000个随机数中的质数 --- 单线程与多线程

① 创建IsPrime类，判断质数的工具

public class IsPrime {
    // 输入一个数,判断是否为质数,费时方法
    static boolean isPrime(int num) {
        if (num == 0 || num == 1)
            return false;
        for (int i = 2; i < num - 1; i++) {
            if (num % i == 0) return false;
        }
        return true;
    }
}

② 单线程

/**
 * 单线程方式
 */
public class SingleThread {
    // 接收一个集合
    public static void getResult(List<Integer> list){
        // 方法一:单线程
        int count = 0;
        long startTime = System.currentTimeMillis();
        for (Integer integer : list) {
            count = count + (IsPrime.isPrime(integer) ? 1:0);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("使用单线程:一共"+count+"个质数,大概用了"+(endTime - startTime)+"毫秒");
    }
}

③ 多线程（Java8中paralleStream）

/**
 * java 8 中ParallelStream.forEach()并行遍历循环
 */
public class ParallelStream {
    public static void getResult(List<Integer> list){
        int count = 0;
        long startTime = System.currentTimeMillis();
        count += list.parallelStream().mapToInt(value -> (IsPrime.isPrime(value) ? 1 : 0)).sum();
        long endTime = System.currentTimeMillis();

        System.out.println("使用多线程:一共"+count+"个质数,大概用了"+(endTime - startTime)+"毫秒");
    }
}

④ ForkJoin（Fork是将一个大任务拆分成若干个子任务，子任务分别去计算，而Join是获取到子任务的计算结果，然后合并，这个是递归的过程）

/**
 * 使用ForkJoin并行递归.将99999用二分法分成多个任务,每一个任务中的索引个数不超过5000个,
 * 当且仅当end-start<=5000 == MAX_NUM的时候,小任务开始执行,否则继续分
 */
public class ForkJoin{

    List<Integer> list;
    int num;
    public ForkJoin(List<Integer> list){
        this.list = list;
    }
    static final int MAX_NUM = 5000; // 每一个小任务forkJoinTask最多不超过5千个

    // Fork是将一个大任务拆分成若干个子任务，子任务分别去计算，
    // 而Join是获取到子任务的计算结果，然后合并，这个是递归的过程。
    class AddTask extends RecursiveTask<Integer>{
        int start;                       // 每一个小任务开始的索引
        int end;                         // 每一个小任务结束的索引
        public AddTask(int start,int end){
            this.start = start;
            this.end = end;
        }
        @Override
        protected Integer compute() {
            if(end - start <= MAX_NUM){
                // 开始执行子任务
                int count = 0;
                for (int i = start; i < end; i++) {
                    count += (IsPrime.isPrime(list.get(i)) ? 1:0);
                }
                return count;
            }else {
                // 大于5000,二分法
                int middle = start + (end - start)/2;
                // 会执行核心方法compute,递归
                AddTask task1 = new AddTask(start, middle);
                AddTask task2 = new AddTask(middle, end);
                // 分别执行
                task1.fork();
                task2.fork();
                // 合并结果并返回
                return task1.join() + task2.join();
            }
        }
    }

    public void getResult(){
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        AddTask task = new AddTask(0, list.size());
        // 并发,执行task
        long startTime = System.currentTimeMillis();
        forkJoinPool.execute(task);
        // 获取结果
        int totalConut = task.join();
        long endTime = System.currentTimeMillis();

        System.out.println("使用多线程:一共"+totalConut+"个质数,大概用了"+(endTime - startTime)+"毫秒");
    }
}

⑤ 测试类

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 100000; i++) list.add(r.nextInt(1000000));

        SingleThread.getResult(list);
        ParallelStream.getResult(list);
        new ForkJoin(list).getResult();
    }

}

⑥ 结果

使用单线程:一共9588个质数,大概用了2974毫秒
使用多线程:一共9588个质数,大概用了1176毫秒
使用多线程:一共9588个质数,大概用了1157毫秒

⑦ 如果对质数算法进行优化

质数:只能被1和自身整除
0和1不是质数,2和3是质数,
大于5的不在6的两侧的数为6x-2,6x+2,6x+3,6x+4,其中x>=1,可知道都能提取公因数,因此都不是质数

    static boolean isPrime(int num){
        // 两个较小数另外处理
        if(num ==1)
            return false;
        if(num ==2 || num==3)
            return true;
        // 不在6的倍数两侧的一定不是质数
        if(num % 6 != 1 && num % 6 !=5)
            return false;
        // 在6的倍数两侧的也不一定是质数
        double temp = Math.sqrt(num);
        // 将0排外
        for(int i = 5;i <= temp;i += 6){
            if(num % i == 0 || num % (i+2) == 0)
                return false;
        }
        return true;
    }

则结果为
使用单线程:一共9674个质数,大概用了31毫秒
使用多线程:一共9674个质数,大概用了140毫秒
使用多线程:一共9674个质数,大概用了29毫秒
此时的ForkJoin与单线程不相上下,而parallelStream比单线程的还慢
此时再加大数据量,多线程的优势才会体现出来