CompletableFuture(异步编程详解)
CompletableFuture
一、runAsync
1.1、runAsunc（一个Runnable接口）
package com.thread.study.jdksyn;
import java.util.concurrent.*;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 14:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
System.out.println("当前线程为：" + Thread.currentThread().getName());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
voidCompletableFuture.get();
System.out.println("运行后再运行这个结果");
}
}
1.2、runAsync（一个Runnable接口，自定义线程池）
package com.thread.study.jdksyn;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 14:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/**
* 自定义线程池
* ThreadFactory接口中只有一个方法
* Thread newThread(Runnable r);
*/
AtomicInteger atomicInteger = new AtomicInteger(0);
ExecutorService executorService = Executors.newFixedThreadPool(2,(runnable)->{
Thread thread=new Thread(runnable);
thread.setName("zqs_"+atomicInteger);
return thread;
});
/**
* 使用自定义线程池做完成异步编程
*/
CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
System.out.println("当前线程为：" + Thread.currentThread().getName());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, executorService);
voidCompletableFuture.get();
System.out.println("运行后再运行这个结果");
executorService.shutdown();
}
}
二、supplyAsync（有返回结果）
用法和runAsync 一样
有一个参
有两个参
package com.thread.study.jdksyn;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 15:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/**
* 自定义线程池
*/
AtomicInteger atomicInteger = new AtomicInteger(0);
ExecutorService executorService = Executors.newFixedThreadPool(2, (runnable) -> {
Thread thread = new Thread(runnable);
thread.setName("zqs_" + atomicInteger);
return thread;
});
/**
* 使用自定义线程池做完成异步编程supply(运输)
*/
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println("执行任务1");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "任务1完成";
}, executorService);
String s = completableFuture.get();
System.out.println(s);
}
}
三、thenApply 和 thenApplyAsync
thenApply (两个任务) 使用的线程是一个
thenApplyAsync（两个任务）使用的线程可以不是一个
特点：都是顺序执行，都有返回值
package com.thread.study.jdksyn;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 15:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/**
* 自定义线程池
*/
AtomicInteger atomicInteger = new AtomicInteger(0);
ExecutorService executorService = Executors.newFixedThreadPool(2, (runnable) -> {
Thread thread = new Thread(runnable);
thread.setName("zqs_" + atomicInteger);
return thread;
});
/**
* 使用自定义线程池做完成异步编程supply(运输)
*/
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
System.out.println("任务1线程名："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
return "aaa";
}, executorService).thenApplyAsync(s->{
String s1 = s.toUpperCase();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务2线程名："+Thread.currentThread().getName());
return s1;
});
String s = completableFuture.get();
System.out.println(s);
}
}
测试结果：
四、thenAccept()和 thenAcceptAsync（）
跟上面的方法类似，只不过没有返回值,参数是消费者接口
package com.thread.study.jdksyn;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 15:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/**
* 自定义线程池
*/
AtomicInteger atomicInteger = new AtomicInteger(0);
ExecutorService executorService = Executors.newFixedThreadPool(2, (runnable) -> {
Thread thread = new Thread(runnable);
thread.setName("zqs_" + atomicInteger);
return thread;
});
/**
* 使用自定义线程池做完成异步编程supply(运输)
*/
CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
System.out.println("任务1线程名："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
return "aaa";
}, executorService).thenAcceptAsync(s->{
String s1 = s.toUpperCase();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务2线程名："+Thread.currentThread().getName());
});
Void aVoid = completableFuture.get();
System.out.println(aVoid);
}
}
五、thenRun()
跟上面方法类似，只不过拿不到参数，参数为一个runnable对象
executorService).thenRun(()->{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务2线程名："+Thread.currentThread().getName());
六、thenCompose（然后组装）
第一个任务完成（参数）然后给第二个任务
所以两者是有关系的
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<String> completableFuture = getProjectId().thenCompose(id -> getProjectById(id));
System.out.println("获得最终的结果为："+completableFuture.get());
}
//根据某某条件获得商品id
private static CompletableFuture<Integer> getProjectId(){
return CompletableFuture.supplyAsync(()->{
System.out.println("当前执行的线程为："+Thread.currentThread().getName());
System.out.println("这里面执行了非常多的操作然后得到了一个项目ID");
return 10;
});
}
//根据上面获得商品id去查询商品的详细信息
private static CompletableFuture<String> getProjectById(int id){
return CompletableFuture.supplyAsync(()->{
System.out.println("当前执行的线程为："+Thread.currentThread().getName());
System.out.println("这里面执行了非常多的操作然后根据id获得了商品的详细信息,id:"+id);
return "华为手机";
});
}
}
七、thenCombine（）
组装没有联系
看谁的速度快先执行完谁
package com.thread.study.jdksyn;
import java.util.concurrent.*;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 15:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<Integer> integerCompletableFuture1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
System.out.println("任务1");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 1;
});
CompletableFuture<Integer> integerCompletableFuture2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
System.out.println("任务2");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 2;
});
CompletableFuture<Integer> integerCompletableFuture = integerCompletableFuture1.thenCombine(integerCompletableFuture2, (id1, id2) -> {
return id1 + id2;
});
System.out.println(integerCompletableFuture.get());
}
}
八、allOf（）
全部执行完成才执行下面的
package com.thread.study.jdksyn;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 15:29
* @Version 1.0
**/
public class CompletableFutureTest {
private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger(0);
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第一个task");});
CompletableFuture<Void> completableFuture2 = CompletableFuture.runAsync(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第二个task");});
CompletableFuture<Void> completableFuture3 = CompletableFuture.runAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第三个task");});
//希望上面三个任务都完成才继续后面
CompletableFuture<Void> allOf = CompletableFuture.allOf(completableFuture1, completableFuture2, completableFuture3);
allOf.join();
System.out.println("三个任务全部结束，现在可以继续后面的工作");
}
}
九、anyOf（)
和上面用法一样
但是有一个任务完成就执行下面的任务
十、异常处理
10.1、在任务链执行完加一个 .exceptionally（）
有返回值
package com.thread.study.jdksyn;
import java.util.concurrent.*;
/**
* @ClassName
* @Description TODO
* @Author ZQS
* @Date 2020/9/9 0009 15:29
* @Version 1.0
**/
public class CompletableFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<String> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println("supplyAsync方法执行");
throw new RuntimeException("在supplyAsync方法中出现异常");
}).thenApply(s -> {
System.out.println("因为上面出现了异常我就不会执行了");
return "不会执行";
}).exceptionally(e-> {
System.out.println(Thread.currentThread().getName()+"执行过程中出现了异常了"+e);
return "凉凉";
});
System.out.println(voidCompletableFuture.get());;
System.out.println("出现异常不执行了");
}
}
十一、handle()
有没有异常都会执行，可以根据判断来返回不同的东西