1. 首页
  2. 文章中心
  3. 大龄程序员随记

Java精简高效异步编程实战

148 阅读 0 评论
我是靠谱客的博主 糟糕蜡烛，这篇文章主要介绍Java精简高效异步编程实战，现在分享给大家，希望可以做个参考。

背景

在Java编程中，经常需要异步执行某个任务，一般继承Thread类或实现Runnable接口的方法来异步执行任务，除了这两种方法外，还可实现Callable来实现，在使用Callable的同时一般都会使用Future来配合获取执行结果，这几种方式使用起来或多或少存在不足，在jdk1.8中，提供了一个异步处理任务的工具CompletableFuture，接下来就通过实际代码体验CompletableFuture的使用。

创建异步线程任务

根据supplier创建CompletableFuture任务

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> System.out.println("hello CompletableFuture1"), executor);
// supplyAsync的使用
CompletableFuture<String> future = CompletableFuture
.supplyAsync(() -> {
System.out.print("hello ");
return "CompletableFuture2";
}, executor);
// 阻塞等待，runAsync 的future 无返回值，输出null
System.out.println(completableFuture.join());
// 阻塞等待
String name = future.join();
System.out.println(name);
executor.shutdown();
--------输出结果--------
hello CompletableFuture1
null
hello CompletableFuture2

线程串行执行

任务完成则运行action，不关心上一个任务的结果，无返回值

复制代码
1
2
3
4
5
6
7
CompletableFuture<Void> future = CompletableFuture
.supplyAsync(() -> "hello siting", executor)
.thenRunAsync(() -> System.out.println("OK"), executor);
executor.shutdown();
--------输出结果--------
OK

任务完成则运行fn，依赖上一个任务的结果，有返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<String> future = CompletableFuture
.supplyAsync(() -> "hello world", executor)
.thenApplyAsync(data -> {
System.out.println(data); return "OK";
}, executor);
System.out.println(future.join());
executor.shutdown();
--------输出结果--------
hello world
OK

thenCompose - 任务完成则运行fn，依赖上一个任务的结果，有返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//第一个异步任务，常量任务
CompletableFuture<String> f = CompletableFuture.completedFuture("OK");
//第二个异步任务
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<String> future = CompletableFuture
.supplyAsync(() -> "hello world", executor)
.thenComposeAsync(data -> {
System.out.println(data); return f; //使用第一个任务作为返回
}, executor);
System.out.println(future.join());
executor.shutdown();
--------输出结果--------
hello world
OK

线程并行执行

两个CompletableFuture并行执行完，然后执行action，不依赖上两个任务的结果，无返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
//第一个异步任务，常量任务
CompletableFuture<String> first = CompletableFuture.completedFuture("hello world");
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<Void> future = CompletableFuture
//第二个异步任务
.supplyAsync(() -> "hello siting", executor)
// () -> System.out.println("OK") 是第三个任务
.runAfterBothAsync(first, () -> System.out.println("OK"), executor);
executor.shutdown();
--------输出结果--------
OK

两个CompletableFuture并行执行完，然后执行action，依赖上两个任务的结果，无返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
//第一个异步任务，常量任务
CompletableFuture<String> first = CompletableFuture.completedFuture("hello world");
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<Void> future = CompletableFuture
//第二个异步任务
.supplyAsync(() -> "hello siting", executor)
// (w, s) -> System.out.println(s) 是第三个任务
.thenAcceptBothAsync(first, (s, w) -> System.out.println(s), executor);
executor.shutdown();
--------输出结果--------
hello siting

两个CompletableFuture并行执行完，然后执行fn，依赖上两个任务的结果，有返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//第一个异步任务，常量任务
CompletableFuture<String> first = CompletableFuture.completedFuture("hello world");
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<String> future = CompletableFuture
//第二个异步任务
.supplyAsync(() -> "hello siting", executor)
// (w, s) -> System.out.println(s) 是第三个任务
.thenCombineAsync(first, (s, w) -> {
System.out.println(s);
return "OK";
}, executor);
System.out.println(future.join());
executor.shutdown();
--------输出结果--------
hello siting
OK

线程并行执行（二者选其最快）

线程并行执行，谁先执行完则谁触发下一任务

上一个任务或者other任务完成, 运行action，不依赖前一任务的结果，无返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 第一个异步任务，休眠1秒，保证最晚执行晚
CompletableFuture<String> first = CompletableFuture.supplyAsync(()->{
try{ Thread.sleep(1000); }catch (Exception e){}
System.out.println("hello world");
return "hello world";
});
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<Void> future = CompletableFuture
// 第二个异步任务
.supplyAsync(() ->{
System.out.println("hello siting");
return "hello siting";
} , executor)
// () ->
System.out.println("OK") 是第三个任务
.runAfterEitherAsync(first, () ->
System.out.println("OK") , executor);
executor.shutdown();
--------输出结果--------
hello siting
OK

上一个任务或者other任务完成, 运行action，依赖最先完成任务的结果，无返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 第一个异步任务，休眠1秒，保证最晚执行晚
CompletableFuture<String> first = CompletableFuture.supplyAsync(()->{
try{ Thread.sleep(1000);
}catch (Exception e){}
return "hello world";
});
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<Void> future = CompletableFuture
// 第二个异步任务
.supplyAsync(() -> "hello siting", executor)
// data ->
System.out.println(data) 是第三个任务
.acceptEitherAsync(first, data ->
System.out.println(data) , executor);
executor.shutdown();
--------输出结果--------
hello siting

上一个任务或者other任务完成, 运行fn，依赖最先完成任务的结果，有返回值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//第一个异步任务，休眠1秒，保证最晚执行晚
CompletableFuture<String> first = CompletableFuture.supplyAsync(()->{
try{ Thread.sleep(1000);
}catch (Exception e){}
return "hello world";
});
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<String> future = CompletableFuture
//第二个异步任务
.supplyAsync(() -> "hello siting", executor)
// data ->
System.out.println(data) 是第三个任务
.applyToEitherAsync(first, data ->
{
System.out.println(data);
return "OK";
} , executor);
System.out.println(future);
executor.shutdown();
--------输出结果--------
hello siting
OK

处理任务结果或者异常

exceptionally-处理异常：如果之前的处理环节有异常问题，则会触发exceptionally的调用相当于 try…catch

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
CompletableFuture<Integer> first = CompletableFuture
.supplyAsync(() -> {
if (true) {
throw new RuntimeException("main error!");
}
return "hello world";
})
.thenApply(data -> 1)
.exceptionally(e -> {
e.printStackTrace(); // 异常捕捉处理，前面两个处理环节的日常都能捕获
return 0;
});

handle-任务完成或者异常时运行fn，返回值为fn的返回

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
CompletableFuture<Integer> first = CompletableFuture
.supplyAsync(() -> {
if (true) { throw new RuntimeException("main error!"); }
return "hello world";
})
.thenApply(data -> 1)
.handleAsync((data,e) -> {
e.printStackTrace(); // 异常捕捉处理
return data;
});
System.out.println(first.join());
--------输出结果--------
java.util.concurrent.CompletionException: java.lang.RuntimeException: main error!
... 5 more
null

whenComplete-任务完成或者异常时运行action，有返回值

  • whenComplete与handle的区别在于，它不参与返回结果的处理，把它当成监听器即可

  • 即使异常被处理，在CompletableFuture外层，异常也会再次复现

  • 使用whenCompleteAsync时，返回结果则需要考虑多线程操作问题，毕竟会出现两个线程同时操作一个结果

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
CompletableFuture<AtomicBoolean> first = CompletableFuture
.supplyAsync(() -> {
if (true) {
throw new RuntimeException("main error!"); }
return "hello world";
})
.thenApply(data -> new AtomicBoolean(false))
.whenCompleteAsync((data,e) -> {
//异常捕捉处理, 但是异常还是会在外层复现
System.out.println(e.getMessage());
});
first.join();
--------输出结果--------
java.lang.RuntimeException: main error!
Exception in thread "main" java.util.concurrent.CompletionException: java.lang.RuntimeException: main error!
... 5 more

多个任务的简单组合

复制代码
1
2
3
4
5
6
7
8
9
10
11
 CompletableFuture<Void> future = CompletableFuture
.allOf(CompletableFuture.completedFuture("A"),
CompletableFuture.completedFuture("B"));
//全部任务都需要执行完
future.join();
CompletableFuture<Object> future2 = CompletableFuture
.anyOf(CompletableFuture.completedFuture("C"),
CompletableFuture.completedFuture("D"));
//其中一个任务行完即可
future2.join();

取消执行线程任务

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
CompletableFuture<Integer> future = CompletableFuture
.supplyAsync(() -> {
try { Thread.sleep(1000);
} catch (Exception e) { }
return "hello world";
})
.thenApply(data -> 1);
System.out.println("任务取消前:" + future.isCancelled());
// 如果任务未完成,则返回异常,需要对使用exceptionally，handle 对结果处理
future.cancel(true);
System.out.println("任务取消后:" + future.isCancelled());
future = future.exceptionally(e -> {
e.printStackTrace();
return 0;
});
System.out.println(future.join());
--------输出结果--------
任务取消前:false
任务取消后:true
java.util.concurrent.CancellationException
at java.util.concurrent.CompletableFuture.cancel(CompletableFuture.java:2276)
at Test.main(Test.java:25)

如有疑问请提issue: https://gitee.com/huangmike/itshare

最后

以上就是糟糕蜡烛最近收集整理的关于Java精简高效异步编程实战的全部内容，更多相关Java精简高效异步编程实战内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(98)

相关文章

深入Javascript异步编程深入Javascript异步编程
深入Javascript异步编程深入Javascript异步编程
【深扒】深入理解 JavaScript 中的异步编程
【深扒】深入理解 JavaScript 中的异步编程
JAVA 异步编程的简单实现一.场景二.分析三.总结
JAVA 异步编程的简单实现一.场景二.分析三.总结
javascript异步编程的解决方案javascript异步编程的解决方案
javascript异步编程的解决方案javascript异步编程的解决方案
Java精简高效异步编程实战
Java精简高效异步编程实战
详解JavaScript异步执行顺序单线程的JavaScriptJavaScript中的任务执行异步任务过程详解微任务和宏任务
详解JavaScript异步执行顺序单线程的JavaScriptJavaScript中的任务执行异步任务过程详解微任务和宏任务
第九章Java异步编程
第九章Java异步编程
JavaScript异步编程
JavaScript异步编程

评论列表共有 0 条评论

立即
投稿
返回
顶部