09-Stream流式计算&ForkJoin&异步回调

15.Stream流式计算

什么是Stream流式计算

大数据：存储+计算

存储：Nysqk 本质就是存储东西的；

计算都应该交给流来操作

User  id name age

---

16.ForkJoin

什么是ForkJoin

ForkJoin在JDK1.7，并行执行任务！提高效率

大数据 Map Reduce （把大任务拆成小任务）

ForkJoin特点：工作窃取

这个里面维护的都是双端队列

ForkJoin操作 大数据量才能体现

package forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * 如何使用forkjoin
 * 1.ForkJoinPool 通过他来执行
 * 2.计算任务 ForkJoinPool.execute(ForkJoinTask task)
 * 3.计算类要继承ForkJoinTask
 */
public class ForkJoinDemo  extends RecursiveTask<Long> {
    private Long start;
    private Long end;

    //临界值
    private Long temp=10000L;

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }
    //计算方法
    @Override
    protected Long compute() {
        if((end-start)<temp){
            long sum=0L;
            for (Long i = start; i <= end; i++) {
                sum+=i;
            }
            return sum;
        }else {
            Long middle=(start+end)/2;
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork();//拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork();
         return  task1.join()+task2.join();
        }
    }
}

测试类

package forkjoin;

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1();//9173
        test2(); //4245
        //test3();//1150
    }
    //普通程序员
    public static void test1(){
        long start =System.currentTimeMillis();
        Long sum=0L;
        for (Long i = 1L; i < 10_0000_0000; i++) {
            sum+=i;
        }

        long end =System.currentTimeMillis();
        System.out.println("sum="+sum+"----时间:"+(end-start));
    }
    //会使用Forkjoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start =System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> sumbit=forkJoinPool.submit(task);
        Long sum = sumbit.get();

        long end =System.currentTimeMillis();
        System.out.println("sum="+sum+"----时间:"+(end-start));

    }
    public static void test3(){
        long start =System.currentTimeMillis();

        //stream 并行流
        LongStream.rangeClosed(0L,10_0000_10000L).parallel().reduce(0,Long::sum);


        long end =System.currentTimeMillis();
        System.out.println("sum="+"----时间:"+(end-start));
    }
}

---

17.异步回调

future

package future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * 异步回调 completableFuture   （Ajax）
 * 异步回调
 * 成功回调
 * 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值的runAsync 异步回调
    /*    CompletableFuture<Void> completableFuture=CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync");
        });
        System.out.println("111111111");
        completableFuture.get();//获取阻塞执行结果
*/
        //有返回值的 supplyAsync 异步回调
        CompletableFuture<Integer> completableFuture=CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync-----Integer");
            int i=10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t,u)->{
            System.out.println("t--->"+t);//正常的返回结果
            System.out.println("u--->"+u);//错误信息
        }).exceptionally((e)->{
            System.out.println(e.getMessage());//可以获取到错误的返结果
            return 233;
        }).get());
    }
}

---