Forkjoin and stream flow test

What is? ForkJoin?

ForkJoin stay JDK 1.7 , Execute tasks in parallel ！ Increase of efficiency . Large amount of data ！ big data ：Map Reduce （ Split big tasks into small ones ）

ForkJoin characteristic ： Job theft

ForkJoinPool internals - Job theft

stay ForkJoinPool in , Each worker thread in the thread pool （ForkJoinWorkerThread） All correspond to a task queue （WorkQueue）, The worker thread prioritizes tasks from its own queue （LIFO or FIFO The order , Parameters mode decision ）, And then to FIFO Randomly steal tasks from other queues in the order of .

import java.util.concurrent.RecursiveTask;


/** *  The task of summation calculation ！ * 3000 6000（ForkJoin） 9000（Stream Parallel flow ） * //  How to use  forkjoin * // 1、forkjoinPool  To execute through it  * // 2、 Calculation task  forkjoinPool.execute(ForkJoinTask task) * // 3.  The calculation class should inherit  ForkJoinTask */
public class ForkJoinDemo extends RecursiveTask<Long> {
    
    private Long start;
    private Long end;
    // critical value 
    private Long tmp = 10000L;

    public ForkJoinDemo(Long start, Long end) {
    
        this.start = start;
        this.end = end;
    }

    //  computing method 
    @Override
    protected Long compute() {
    
        if ((end-start)<tmp){
    
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
    
                sum += i;
            }
            return sum;
        }else {
     // forkjoin  recursive 
            long middle = (start + end) / 2; //  In the middle 
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); //  Split the task , Push the task into the thread queue 
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork(); //  Split the task , Push the task into the thread queue 
            return task1.join() + task2.join();
        }
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Main {
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
// test1();
// test2();
        test3();
    }
    //  Ordinary programmers 
    public static void test1(){
    
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
    
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"  Time ："+(end-start));
    }
    //  Will use ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
    
        long start = System.currentTimeMillis();

        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L,10_0000_0000L);
        ForkJoinTask<Long> submit = pool.submit(task);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"  Time ："+(end-start));
    }
    // Stream Parallel flow  ():range (]:rangeClosed
    public static void test3(){
    
        long start = System.currentTimeMillis();
        long sum = LongStream.rangeClosed(0L,10_0000_0000L).parallel().reduce(0,Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum +" Time ："+(end-start));
    }

}