Fork/Join框架简单计算案例

package java8.day03.forkJoin01;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.concurrent.RecursiveTask;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ForkJoinCalculate extends RecursiveTask<Long> {

    private long start;
    private long end;

    private static final long THRESHOLD = 10000;



    @Override
    protected Long compute() {

        long length = end - start;
        long sum = 0;

        if(length <= THRESHOLD){
            for(long i = start; i <= end; i++){
                sum += i;
            }
            return sum;
        }else{
            long mid = (start + end)>>1;
            ForkJoinCalculate left = new ForkJoinCalculate(start,mid);
            left.fork();
            ForkJoinCalculate right = new ForkJoinCalculate(mid+1,end);
            right.fork();

            return left.join() + right.join();
        }
    }
}

package java8.day03.forkJoin01;

import org.junit.jupiter.api.Test;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;

public class ForkJoin01 {

    /**
     * Fork Join 框架
     */
    @Test
    public void test01() {
        Instant start = Instant.now();

        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinCalculate(0, 1000000000L);
        Long sum = pool.invoke(task);
        System.out.println(sum);

        Instant end = Instant.now();
        System.out.println("耗费时间 ： " + Duration.between(start, end).toMillis()); //304ms
    }
    /**
     *
     * 普通for循环
     *
     */
    @Test
    public void test02() {
        Instant start = Instant.now();

        long sum = 0;
        for (long i = 0; i <= 1000000000L; i++) {
            sum += i;
        }
        System.out.println(sum);

        Instant end = Instant.now();
        System.out.println("耗费时间 ： " + Duration.between(start, end).toMillis());   //393ms

    }
    
    /**
     *
     * Java8 并行流
     *
     */
    @Test
    public void test03(){
        Instant start = Instant.now();

        long sum = LongStream.rangeClosed(0, 1000000000L)
                .parallel()
                .sum();
        System.out.println(sum);

        Instant end = Instant.now();
        System.out.println("耗费时间 ： " + Duration.between(start, end).toMillis());   //393ms

    }
}

1. test01()自己写的Fork/Join框架实现求和
2. test02()不采用Fork/Join框架实现求和
3. test03()采用java8支持的并行流进行实现，原理同test01()相近 只是java8帮我们写好了底层，对并行更加友好

Fork/Join框架：按照我的理解其实就是将任务分而治之、递归执行，但是通过多线程 加速了子任务的执行，使得多核的计算机更好地利用系统效率。

具体执行的细节：假如CPU1处理的线程已经全部处理完，CPU2待处理的线程还有很多，那么CPU1不会空闲，而会把CPU2的队列中的线程拿出来进行处理。这样就是得CPU利用率更高，当数据较大，任务较多时能够有效提高总的消耗时间。