Fork/Join框架运用

Fork/Join是一种基于“分治”的算法：通过分解任务，并行执行，最后合并结果得到最终结果。

ForkJoinPool线程池可以把一个大任务分拆成小任务并行执行，任务类必须继承自RecursiveTask（带返回值）或RecursiveAction（不带返回值）。使用Fork/Join模式可以进行并行计算以提高效率。

案例：从1加到1000000000

public class ForkJoinCalculate extends RecursiveTask {
    private  long strat;
    private long end;
//    临界值
    private static final long THRESHOLD = 10000;
    public  ForkJoinCalculate(long strat,long end){
        this.strat = strat;
        this.end = end;
    }
@Override
    protected Long compute() {
    long length = end-strat;
    if(length<=THRESHOLD){
        long sum =0;
        for(long i =strat;i<=end;i++){
            sum+=i;
        }
        return sum;
    }else{
        long middle =(strat+end)/2;
//        创建类的实例
       ForkJoinCalculate left = new ForkJoinCalculate(strat,middle);
//        拆分子任务，同时压入线程队列
        left.fork();

        ForkJoinCalculate right = new ForkJoinCalculate(middle+1,end);

//        串行流：比单线程（for循环）效率高得多
//        Instant start1 = Instant.now();
        rangeClosed生成一系列连续的数
//        LongStream.rangeClosed(1,10000000000L)
                串行流
//                .parallel()
//                .reduce(Long::sum);
//        Instant end1 = Instant.now();
//        System.out.println(Duration.between(start1, end1).toMillis());
        right.fork();
//        合并
        return left.join()+right.join();

    }
    }


}

public class TestForkjoin {
    public static void main(String[] args) {
//        计算时间戳
        Instant start = Instant.now();
//        创建线程池
       ForkJoinPool pool = new ForkJoinPool();
       ForkJoinTask task = new ForkJoinCalculate(0,10000000000L);
//       invoke调用我们所提供的方法以及调用方法的参数来完成动态调用。
       Long sum =pool.invoke(task);
        System.out.println(sum);

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());

//        顺行流：比单线程（for循环）效率高得多
//        Instant start1 = Instant.now();
        rangeClosed生成一系列连续的数
//        LongStream.rangeClosed(1,10000000000L)
                串行流
//                .parallel()
//                .reduce(Long::sum);
//        Instant end1 = Instant.now();
//        System.out.println(Duration.between(start1, end1).toMillis());

数值太大所以显示结果错误

 Optional容器类

 实例

public class Test {
    public static void main(String[] args) {
        /*
        Optional.of（T t）:创建一个Optional实例
         Optional.empty():创建一个空的 Optional实例
         Optional。ofNullable（T t）：若t不为空，创建 Optional实例，否则创建空实例
         isPresent（）：判断是否包含值
         orElse(T t):如果调用对象包含值，返回该值，否则返回t
         orElseGet（Supplier s）：如果调用对象包含值，返回该值否则返回s获取的值
         map（Function f):如果有值对其处理，并返回处理后的 Optional，否则返回 Optional。empty（）
         flatMap（Function mapper）：与map类似，要求返回值必须是 Optional
         */
//        Optional.of（null）:若传入null快速锁定空指针位置
Optional op = Optional.of(new Employee());
Employee emp = op.get();
        System.out.println(emp);

        Optional op1 =Optional.empty();
        System.out.println(op.get());

        Optional op3 = Optional.ofNullable(new Employee());
        System.out.println(op3.get());
ofNullable（null）:若传入null快速锁定空指针位置
//        Optional op2 = Optional.ofNullable(null);
//        System.out.println(op2.get());

//        判断是否有值有值get获取
        Optional op4 = Optional.ofNullable(new Employee());
        if(op4.isPresent()){
            System.out.println(op3.get());
        }
//        如果有值返回该值，没值获取默认值（自己写的值）
        Employee emp1 = op4.orElse(new Employee("张三",18,111111));

//  orElseGet（Supplier s）：Supplier供给型接口与上边的区别可将new Employee()换成{任何功能}
      Employee emp3 =   op4.orElseGet(()->new Employee());
        System.out.println(emp3);

Optional op5 = Optional.ofNullable(new Employee("张三",18,111111));
//把容器对象new Employee应用到map上
Optional str =op.map((e)->e.getName());
        System.out.println(str);


    }

 接口中的默认方法