Stream流式计算和ForkJoin&异步回调讲解

什么是Stream流式计算

大数据：存储+计算

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

计算都应该交给流来操作

User id name age

---

什么是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));

}

}

---

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());

}

}