1、ForkJoin
特点:工作窃取 里边维护的是双端队列
package com.zkw.JUC并发编程.forkjoin;
import java.util.concurrent.RecursiveTask;
public class ForkJoinDemon extends RecursiveTask<Long> {
private Long start;
private Long end;
//临界值
private Long temp = 1_0000L;
public ForkJoinDemon(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 = (end+start)/2;
ForkJoinDemon task1 = new ForkJoinDemon(start, middle);
task1.fork(); //拆分任务,把线程压入到队列中
ForkJoinDemon task2 = new ForkJoinDemon(middle + 1, end);
task2.fork();
return task1.join() + task2.join();
}
}
}
package com.zkw.JUC并发编程.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();//9288
//test2();//8273
test3();//238
}
public static void test1(){
Long sum = 0L;
long start = System.currentTimeMillis();
for (Long i = 1L; i <= 10_0000_0000L; 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();
ForkJoinDemon task = new ForkJoinDemon(1L, 10_0000_0000L);
ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
Long sum = submit.get();
long end = System.currentTimeMillis();
System.out.println("sum = "+sum+" "+"时间:"+(end-start));
}
//Stream 并行流
public static void test3(){
long start = System.currentTimeMillis();
Long sum = LongStream.range(0L,10_0000_0001L).parallel().reduce(0,Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum = "+sum+" "+"时间:"+(end-start));
}
}
2、异步回调
package com.zkw.JUC并发编程.future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* 异步回调 CompletableFuture
* 异步执行
* 成功回调
* 失败回调
*/
public class Demon01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/* //没有返回值的异步回调
CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
});
System.out.println("1111111");
future.get();// 获取阻塞执行结果*/
//有返回值的 supplyAsync 异步回调
// ajax ,成功和失败回调
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
int i= 10/0;
return 1024;
});
System.out.println(future1.whenComplete((t, u) -> {
System.out.println("t=>" + t);//正常的返回结果
System.out.println("u=>" + u); //错误信息
}).exceptionally((e) -> {
System.out.println(e.getMessage());
return 233; //错误的返回结果
}).get());
}
}