使用场景:一个接口需要查询五部分数据,a,b,c三部分数据直接没有关系,可以并行查询,但是,d,e数据需要等a数据查询结果返回才可以查询,如果使用普通的FutureTask可以实现,但是在项目中,我们不是直接new Thread的,需要使用线程池,所以 CompletableFuture,既可以异步编排,又可以使用线程池执行.
启动异步任务 runAsync supplyAsync
package com.buba.springbootdemo.thread;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
*
*/
public class Demo {
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
/**
* 异步执行,无返回值
* public static CompletableFuture<Void> runAsync(Runnable runnable)
* public static CompletableFuture<Void> runAsync(Runnable runnable,Executor executor)
*/
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> System.out.println("线程执行"), executor);
/**
* 有返回值
* public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
* public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,Executor executor)
*/
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 1, executor);
//返回1
System.out.println(future2.get());
}
}
完成回调与异常感知 whenComplete exceptionally
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
/**
* whenComplete当前面的线程执行完后执行的操作,没有async的方法表示跟前面的线程用同一个线程执行,加async的方法表示使用新的线程执行
* exceptionally,表示如果出现异常的话执行的方法,没有异常不会执行,并且它可以修改返回值,而whenComplete不可以修改返回值
*
* public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)
* public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor)
* public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)
*
* 返回的结果:null,异常信息:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
* java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
* 10
*/
CompletableFuture<Integer> future1 = CompletableFuture
.supplyAsync(() -> 1/0, executor)
.whenCompleteAsync((result,exception)-> System.out.println("返回的结果:"+result+",异常信息:"+exception),executor)
.exceptionally((ex)->{
System.out.println(ex);
return 10;
});
System.out.println(future1.get());
}
完成回调与异常感知 handle
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
/**
*
* handle方法跟whenComplete一样都是当之前的线程执行完再执行,但是它可以修改返回的结果
*
* public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)
* public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn)
* public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor)
*
* 返回结果:1,异常信息:null
* 2
*/
CompletableFuture<Integer> future2 = CompletableFuture
.supplyAsync(() -> 1, executor)
.handleAsync((result,exception)->{
System.out.println("返回结果:"+result+",异常信息:"+exception);
return 2;
},executor);
System.out.println(future2.get());
}
线程串行化 thenRun,thenAccept,thenApply
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
/**
* thenRun等之前线程执行完再执行,获取不到之前线程返回结果,自己当前线程也没有返回结果
* public CompletableFuture<Void> thenRun(Runnable action)
* public CompletableFuture<Void> thenRunAsync(Runnable action)
* public CompletableFuture<Void> thenRunAsync(Runnable action,Executor executor)
*/
CompletableFuture<Void> future1 = CompletableFuture
.supplyAsync(() -> 1, executor)
.thenRunAsync(() -> System.out.println("后续线程执行"), executor);
/**
* thenAccept等之前线程执行完再执行,能获取到之前线程返回结果,自己当前线程没有返回结果
* public CompletableFuture<Void> thenAccept(Consumer<? super T> action)
* public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)
* public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor)
*/
CompletableFuture<Void> future2 = CompletableFuture
.supplyAsync(() -> 1, executor)
.thenAcceptAsync((result) -> System.out.println("后续线程执行,前面线程执行结果:" + result), executor);
/**
* thenApply等之前线程执行完再执行,能获取到之前线程返回结果,自己当前线程有返回结果
* public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
* public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)
* public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)
*/
CompletableFuture<Integer> future3 = CompletableFuture
.supplyAsync(() -> 1, executor)
.thenApplyAsync((result) -> {
System.out.println("后续线程执行,前面线程执行结果:" + result);
return 2;
}, executor);
System.out.println(future3.get());
/**
* 后续线程执行
* 后续线程执行,前面线程执行结果:1
* 后续线程执行,前面线程执行结果:1
* 2
*/
}
两任务组合-都要完成 thenCombineAsync ,runAfterBothAsync ,thenAcceptBothAsync
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture future1 = CompletableFuture
.supplyAsync(() -> {
System.out.println("第一个线程执行完了");
return 1;
}, executor);
/**
*
* runAfterBoth等前面两个线程都执行完,再执行的操作,获取不到前面的返回结果,但自己无返回结果
* thenAcceptBoth等前面两个线程都执行完,再执行的操作,可以获取到前面的返回结果,但自己无返回结果
* thenCombine等前面两个线程都执行完,再执行的操作,可以获取到前面的返回结果,自己有返回结果
*/
CompletableFuture
.runAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("第二个线程执行完了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}, executor)
.runAfterBothAsync(future1, () -> System.out.println("前面两个都执行完了执行的"), executor);
CompletableFuture
.supplyAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("第二个线程执行完了");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 2;
}, executor)
.thenAcceptBothAsync(future1, (result1,result2) -> System.out.println("前面两个都执行完了执行的,返回结果1:"+result1+",返回结果2:"+result2), executor);
CompletableFuture future3 = CompletableFuture
.supplyAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("第二个线程执行完了");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 2;
}, executor)
.thenCombineAsync(future1, (result1, result2) -> {
System.out.println("前面两个都执行完了执行的,返回结果1:" + result1 + ",返回结果2:" + result2);
return 3;
}, executor);
System.out.println(future3.get());
}
两任务组合有一个完成 runAfterEitherAsync,acceptEitherAsync,applyToEitherAsync
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture future1 = CompletableFuture
.supplyAsync(() -> {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第一个线程执行完了");
return 1;
}, executor);
/**
*
* runAfterEitherAsync等前面两个线程中其中一个执行完,再执行的操作,获取不到前面的返回结果,但自己无返回结果
* acceptEitherAsync等前面两个线程中其中一个执行完,再执行的操作,可以获取到前面的返回结果,但自己无返回结果
* applyToEitherAsync等前面两个线程中其中一个执行完,再执行的操作,可以获取到前面的返回结果,自己有返回结果
*/
CompletableFuture
.runAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("第二个线程执行完了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}, executor)
.runAfterEitherAsync(future1, () -> System.out.println("前面两个都执行完了执行的"), executor);
CompletableFuture
.supplyAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("第二个线程执行完了");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 2;
}, executor)
.acceptEitherAsync(future1, (result1) -> System.out.println("前面两个都执行完了执行的,返回结果1:"+result1), executor);
CompletableFuture future3 = CompletableFuture
.supplyAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("第二个线程执行完了");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 2;
}, executor)
.applyToEitherAsync(future1, (result1) -> {
System.out.println("前面两个都执行完了执行的,返回结果1:" + result1);
return 3;
}, executor);
System.out.println(future3.get());
}
多任务组合 allOf,anyOf
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println("线程1执行");
return "线程1";
}, executor);
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println("线程2执行");
return "线程2";
}, executor);
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
System.out.println("线程3执行");
return "线程3";
}, executor);
/**
* allOf等待所有的Future执行完毕
* anyOf有一个执行完毕就会接着往下走
*/
CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);
//得调用get方法进行阻塞
allOf.get();
CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2, future3);
System.out.println(anyOf.get());
}
扫一扫
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
