多线程 CompletableFuture(1)

一、CompletableFuture 常用方法
1、获得结果和触发计算
1.1. public T get() 阻塞 返回结果
1.2. public T get(long timeout,TimeUnit unit) 超时不候
1.3. public T join() 阻塞 返回结果
1.4. public T getNow(T valueIfAbsent) 计算完，返回计算完的结果。没计算完，返回设定的
valueifAbsent 的值
1.5. public boolean complete(T value) 是否打断 get 方法，立即返回括号值
package com.gx.thread;
import java.sql.Time;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class CompletableApIDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException,
TimeoutException {
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
return “future over”;
});
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// String result = future.get(); 阻塞
// String result = future.get(1, TimeUnit.SECONDS);//超时不候
// String result = future.join(); 阻塞
// String result = future.getNow(“xxx”);//计算完，返回计算完的结果。没计算完，返
回设定的 valueifAbsent 的值
System.out.println(future.complete(“completeValue”));
System.out.println(future.join());
//是否打断 get 方法，立即返回括号值
}
}
2、对计算结果进行处理
thenApply
2.1. 计算结果存在依赖关系，这两个线程串行化
2.2. 由于存在依赖关系（当前步错，不走下一步），当前步骤有异常的话就叫停
handle
计算结果存在依赖关系，这两个线程串行化
有异常也可以往下一步走，根据带的异常参数可以进一步处理
//对计算结果进行处理
public class CompletableApI2Demo {
public static void main(String[] args) {
future1();
}
//thenApply 当前线程有异常，不走下一步，立马叫听
public static void future1() {
CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“1111”);
return 1;
}).thenApply((f) -> {
int x = 10 / 0;
System.out.println(“2222”);
return f + 2;
}).thenApply((f) -> {//然后应用
System.out.println(“3333”);
return f + 3;
}).whenComplete((v, e) -> {//什么时候完成
if (e = = null) {
System.out.println(“-----计算结果” + v);
}
}).exceptionally(e -> {
e.printStackTrace();
System.out.println(“出现异常”+e.getMessage());
return null;
});
//主线程执行完毕后，默认的线程池也会随之结束
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “主线程去忙其它任务”);
}
//handle() 有异常也可以往下一步走，根据带的异常参数进一步处理
public static void future2() {
CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“1111”);
return 1;
}).handle((f,e) -> {
int x = 10 / 0;
System.out.println(“2222”);
return f + 2;
}).handle((f,e) -> {//然后应用
System.out.println(“3333”);
return f + 3;
}).whenComplete((v, e) -> {//什么时候完成
if (e == null) {
System.out.println(“-----计算结果” + v);
}
}).exceptionally(e -> {
e.printStackTrace();
System.out.println(“出现异常”+e.getMessage());
return null;
});
//主线程执行完毕后，默认的线程池也会随之结束
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “主线程去忙其它任务”);
}
}