java队列异步处理任务 java异步编排

转载

mob6454cc65e0f6 2023-09-30 11:44:03

文章标签 java队列异步处理任务 多线程 java System 线程池 文章分类 Java 后端开发

异步任务编排CompletableFuture

特别说明：JDK1.8+之后引入 CompletableFuture

背景

在一些需求中，我们常常要给前端返回一些复杂的视图数据，数据之间可能有关联，比如查询了A数据之后才可以根据A数据中的一些信息来查询B数据。

再比如 查询A数据与查询B数据一般没有相关性。假设查询A数据需要1秒,查询B数据需要1秒，那么以往的写法中，第一种情况返回给前端的时间总共花费2秒，

第二种情况返回给前端的时间也会是2秒。但这并不是我们愿意看到的，既然A数据跟B数据没有依赖性很强的情况下，应该可以并行查询进行封装，这样返回给前端的时间只需要花费1秒，这样大大增大了吞吐量，所以可以使用异步编排来解决该问题。

1.创建异步对象

提供四个静态方法来创建一个异步操作。

1
2
3
4
5
6
7
8
//创建异步
public static CompletableFuture<Void> runAsync(Runnable runnable);
//创建异步，支持传入线程池
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);
//创建异步,并返回执行后的结果
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> sup);
//创建异步,支持传入线程池,并返回执行后的结果
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> sup, Executor executor)

1.runAsync方法都没有返回结果,supplyAsync方法都是有返回结果.

2.可以支持传入自己的线程池，或不传使用默认。

runAsync示例

1
2
3
4
5
6
7
8
9
10
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//第一种方式: runAsync
CompletableFuture.runAsync(() -> {
    System.out.println("执行runAsync方法....");
}, executorService);
System.out.println("执行main方法....");
//结果:
//执行main方法....
//执行runAsync方法....

supplyAsync示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5); 
//第二种方式:supplyAsync
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行supplyAsync方法...");
    return "hello,world";
}, executorService);
System.out.println("返回的结果是:"+future.get());
System.out.println("执行main方法....");
/**
结果:
执行supplyAsync方法...
返回的结果是:hello,world
执行main方法....
*/
2.完成回调和异常感知

某个异步任务完成之后执行某个任务

1
2
3
4
5
6
7
8
public CompletableFuture<T> whenComplete(
        BiConsumer<? super T, ? super Throwable> action);
//成功后回调异步执行,arg1:上次执行的结果，arg2:上次执行的异常
public CompletableFuture<T> whenCompleteAsync(
        BiConsumer<? super T, ? super Throwable> action);
//成功后回调异步执行,支持传入自己的线程池。arg1:上次执行的结果，arg2:上次执行的异常 
public CompletableFuture<T> whenCompleteAsync(
        BiConsumer<? super T, ? super Throwable> action, Executor executor);

whenComplete与whenCompleteAsync 区别在于 一个是上一个执行完的线程继续执行,一个是交由其他线程来执行。

whenComplete示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//完成回调  成功后执行某个事情
CompletableFuture.supplyAsync(()->{
    System.out.println("刷牙....");
    return "先刷牙";
},executorService).whenComplete((res,err)->{
    System.out.println("洗脸..."+"上一次结果:"+res+"--错误:"+err);
});
System.out.println("执行main方法....");
/*
刷牙....
洗脸...上一次结果:先刷牙--错误:null
执行main方法....
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//完成回调  成功后执行某个事情
CompletableFuture.supplyAsync(()->{
    System.out.println("刷牙....");
    int i=1/0;
    return "先刷牙";
},executorService).whenComplete((res,err)->{
    System.out.println("洗脸..."+"上一次结果:"+res+"--错误:"+err);
});
System.out.println("执行main方法....");
/*
执行main方法....
刷牙....
洗脸...上一次结果:null--错误:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
*/

虽然能得到异常信息，但是没办法修改返回数据。使用方法exceptionally可以得到解决。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//完成回调  成功后执行某个事情
CompletableFuture<String> exceptionally = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙....");
    int i = 1 / 0;
    return "先刷牙";
}, executorService).whenComplete((res, err) -> {
    System.out.println("洗脸..." + "上一次结果:" + res + "--错误:" + err);
}).exceptionally(e->{
    return "异常了";
});
System.out.println("执行结果:"+exceptionally.get());
System.out.println("执行main方法....");
/*
刷牙....
洗脸...上一次结果:null--错误:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行结果:异常了
执行main方法....
*/
3.使用handle方法

以上的whenComplete 以及exceptionally 都可以用handler代替

1
2
3
4
5
6
7
8
9
//由上一个执行的线程来继续执行  T:上一次执行的结果  U:返回结果
public <U> CompletableFuture<U> handle(
        BiFunction<? super T, Throwable, ? extends U> fn);
//由其他线程来执行 T:上一次执行的结果  U:返回结果
public <U> CompletableFuture<U> handleAsync(
        BiFunction<? super T, Throwable, ? extends U> fn);
//由其他线程来执行，支持传入线程池。 T:上一次执行的结果  U:返回结果
public <U> CompletableFuture<U> handleAsync(
        BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);

handle示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> handle = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    int i = 1 / 0;
    return "正常刷完牙了";
}).handleAsync((res, err) -> {
    if (res != null) {
        return res;
    }
    if (err != null) {
        return "刷牙的时候有问题";
    }
    return "返回值是null,但也没抛异常";
},executorService);
System.out.println("执行结果:"+handle.get());
System.out.println("执行main方法....");
/*
刷牙...
执行结果:刷牙的时候有问题
执行main方法....
*/
4.线程串行化方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//上一个任务执行后，接下来执行的任务  由上一次任务执行后的线程继续执行.
public CompletableFuture<Void> thenRun(Runnable action);
//上一个任务执行后，接下来执行的任务  由不同的线程继续执行.
public CompletableFuture<Void> thenRunAsync(Runnable action);
//上一个任务执行后，接下来执行的任务  由线程池继续执行.
public CompletableFuture<Void> thenRunAsync(Runnable action,Executor executor);

//上一个任务执行后，接收并接下来执行的任务
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)；

//上一个任务执行后，接收并接下来执行的任务,并返回结果
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);

thenRun都是无返回值的，不需要上一次任务执行的结果。

thenAccept 都是可以接收到上一次任务执行的结果，用于下一次执行使用。

thenApply 接收上一次执行的结果，并有返回值。

thenRun示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return null;
}, executorService).thenRun(() -> {
    System.out.println("洗脸");
});
//阻塞等待方法
future.get();
/*
刷牙...
洗脸
*/

thenAccept示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService).thenAcceptAsync(result -> {
    System.out.println("接收结果:"+result);
    System.out.println("洗脸");
});
//阻塞等待方法
future.get();
/*
刷牙...
接收结果:我刷完了
洗脸
*/

thenApply示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService).thenApplyAsync(result -> {
    System.out.println("接受结果:"+result);
    System.out.println("洗脸");
    return "我洗完了";
});
//阻塞等待方法
String s = future.get();
System.out.println("最终结果:"+s);
/*
刷牙...
接受结果:我刷完了
洗脸
最终结果:我洗完了
*/
5.两任务组合-都要完成

当两个任务都执行完毕之后，再执行当前任务。

1
2
3
4
5
6
7
8
9
10
11
12
//两个任务都完成,没有接收他们的结果，没有返回值
public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other,Runnable action) 
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action)
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action, Executor executor);
//两个任务都完成 ,接收他们的结果并执行新任务，没有返回值
public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor);
//两个任务都完成 接收他们的结果并执行新任务 并返回当前任务的返回值。
public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn) 
public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn, Executor executor);

runAfterBoth示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("洗脸...");
    return "我洗完了";
}, executorService);
future1.runAfterBothAsync(future2, () -> {
    System.out.println("吃饭");
}, executorService);
/*
刷牙...
洗脸...
吃饭
*/

thenAcceptBoth示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("洗脸...");
    return "我洗完了";
}, executorService);
future1.thenAcceptBothAsync(future2, (f1,f2) -> {
    System.out.println("接受f1结果:"+f1);
    System.out.println("接受f2结果:"+f2);
    System.out.println("吃饭");
}, executorService);
/*
刷牙...
洗脸...
接受f1结果:我刷完了
接受f2结果:我洗完了
吃饭
*/

thenCombine示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("洗脸...");
    return "我洗完了";
}, executorService);
CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (f1, f2) -> {
    System.out.println("接受f1结果:" + f1);
    System.out.println("接受f2结果:" + f2);
    System.out.println("吃饭");
    return "吃完了";
}, executorService);
String s = future3.get();
System.out.println("最终结果:"+s);
/*
刷牙...
洗脸...
接受f1结果:我刷完了
接受f2结果:我洗完了
吃饭
最终结果:吃完了
*/
6.两任务组合-一个完成

只要两个任务完成一个，就会触发第三个任务的执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
//接收某个任务执行完成的结果，有返回值.
public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) 
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn)
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn
                                                   ,Executor executor);
//接收某个任务执行完成的结果，无返回值.
public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) ;
public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action);
public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor);
//不接收某个任务执行完成的结果，也无返回值.
public CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action);
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action) ;
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

  • 赞
  • 收藏
  • 评论
  • 分享
  • 举报

上一篇：android 如何在native绘制文本 安卓view绘制机制

下一篇：hadoop云计算平台 基于hadoop的云计算课程设计

提问和评论都可以，用心的回复会被更多人看到 评论

发布评论

全部评论 () 最热 最新

相关文章

  • [

    CompletableFuture异步任务编排

    CompletableFuture异步任务编排

    ](https://blog.51cto.com/u_15890333/5885136)

    java 异步 Thread 返回结果 线程池

  • [

    java异步编排

    # Java异步编排实现指南## 引言在Java开发中，我们经常会遇到需要执行多个耗时操作的场景，例如网络请求、数据库查询等。为了提高程序的性能和效率，我们可以使用异步编排的方式来处理这些耗时操作，使它们并行执行，从而节省总体执行时间。本文将介绍如何在Java中实现异步编排，并帮助新手开发者快速掌握这一技术。## 异步编排的流程下面是Java异步编排的一般流程，可以用表格展示：|

    ](https://blog.51cto.com/u_16213344/7197245)

    异步任务 线程池 java

  • [

    java 异步多任务队列

    ## Java 异步多任务队列### 引言在日常的编程中，我们经常会遇到需要同时处理多个任务的场景。传统的做法是使用多线程来实现并发处理，但多线程在面对大规模并发任务时会面临一些问题，如线程生命周期管理、上下文切换开销等。为了优化这些问题，Java提供了异步多任务队列的解决方案，使得任务可以在后台异步处理，提高并发性能和系统响应速度。### 什么是异步多任务队列异步多任务队列是一种

    ](https://blog.51cto.com/u_16213445/6985908)

    线程池 任务队列 Java

  • [

    java队列异步处理任务 java异步编排

    异步任务编排CompletableFuture特别说明：JDK1.8+之后引入 CompletableFuture背景在一些需求中，我们常常要给前端返回一些复杂的视图数据，数据之间可能有关联，比如查询了A数据之后才可以根据A数据中的一些信息来查询B数据。再比如 查询A数据与查询B数据一般没有相关性。假设查询A数据需要1秒,查询B数据需要1秒，那么以往的写法中，第一种情况返回给前端的时间总共花费2秒

    ](https://blog.51cto.com/u_16099196/7662954)

    java队列异步处理任务 多线程 java System 线程池

  • [

    java异步任务队列框架 java异步编排

    一、CompletableFuture 异步编排1、业务场景 查询商品详情页的逻辑比较复杂，有些数据还需要远程调用，必然需要花费更多的时间。 假如商品详情页的每个查询，需要如下标注的时间才能完成 那么，用户需要 5.5s 后才能看到商品详情页的内容。很显然是不能接受的。 如果有多个线程同时完成这 6 步操作，也许只需要 1.5s 即可完成响应。2、java8 - CompletableFuture

    ](https://blog.51cto.com/u_16213683/7545084)

    java异步任务队列框架 java 开发语言 后端 返回结果

  • [

    Java异步任务队列 java异步任务如何处理

    场景： 实际项目中，程序操作出了问题，后续要怎么处理是个很重要的问题，如果这个问题是同步操作引起的解决起来比较简单，比如用户注册，如果系统注册失败，后台可以马上返回错误信息，用户也可以马上看到错误点是什么。但是如果是异步操作，比如用户注册成功后，系统异步发送短信给用户，发短信的操作出问题了没有发出去，而且这个操作也不是用户主动操作了，所以可能会出现用户不知道你有这个操作，系统也没办法知道自己操作出

    ](https://blog.51cto.com/u_14120/6586434)

    Java异步任务队列 消息队列 用户注册 异步操作

  • [

    java 如何处理异步队列 java异步任务队列

    什么是消息队列?消息队列，是一个以队列数据结构为基础的一个实体，这个实体是真实存在的。比如程序中的数组，数据库中的表或者redis等等。为什么要使用队列？什么情况下才会使用队列？实时性要求不高，比较耗时间的任务，是队列的最佳应用场景。比如说在某网站注册一个账号，当信息入库注册成功之后，该网站将会发送一封激活邮件，从而激活账号。而发送邮件的操作并不是需要实时响应的。不需要卡在注册界面，等待邮件发送成

    ](https://blog.51cto.com/u_16213654/7317722)

    java 如何处理异步队列 缓存 数据库 消息队列

  • [

    java 异步socket 队列 java异步任务队列

    程序员的成长之路CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。一、创建异步任务1. supplyAsyncsupplyAsync是创建带有返回值的异步任务。它有如下两个

    ](https://blog.51cto.com/u_16099297/6793526)

    java 异步socket 队列 java servlet jvm 开发语言

  • [

    java 异步编排执行框架 java异步处理框架

    前两天看Spring框架参考手册，发现SpringMVC在4.0版本上支持异步请求处理。废话不多说，开始异步请求之旅。什么是异步请求处理？如果我们使用tomcat服务器来开发传统的servlet，那么用户的请求会经过以下流程进入到我们的servelt。客户端发送http请求到tomcat监听的端口。tomcat connector会接收该请求到线程中，并根据http协议解析该请求。解析完报文后，会

    ](https://blog.51cto.com/u_16213626/7490659)

    java 异步编排执行框架 java http 异步请求框架 tomcat 异步请求 xml

  • [

    rxjava实现异步队列 java异步任务队列

    文章目录前言一、异步队列实现思路？二、实现步骤1.加入监听器2.实现监听器3.实现转交处理对象和转交处理线程4.自动转交异步处理5.业务如何添加 前言在某些场景下，操作比较耗时，给用户体验不是很好，这时候我们就会直接想到两种方案，一种是定时任务，一种就是异步队列，那些实时性要求不高，且比较耗时的任务，是队列的最佳应用场景。一、异步队列实现思路？持久化=>插入队列=>出队，当程序突然停

    ](https://blog.51cto.com/u_12831/6309203)

    java 开发语言 异步处理 线程池 监听器

  • [

    java 测试消息队列 java消息队列异步处理任务

    说说这两种的区别，各自适合什么场景？用线程池ExecutorService异步处理：我理解ExecutorService其实也是内部使用了队列（如LinkedBlockingQueue），所以从设计上，其实和使用中间价的消息队列是差不多一致的。只是这里应用服务器既充当生产者又充当消费者，也是消息队列中间价的实现者。这种应该适合非分布式的架构，比如简单的只有一台服务器。使用消息队列：消息队列（指ac

    ](https://blog.51cto.com/u_16099311/7345747)

    java 测试消息队列 redis 消息队列 线程池

  • [

    JAVA异步nio Java异步编排

    在实际开发中，有很多异步场景，为了节约时间或者提高系统的吞吐量，要做一些异步任务，在 Java 中要实现异步通常都是利用 Thread，开启一个线程 Thread。开启线程有四种方式，分别为：

    ](https://blog.51cto.com/u_16099229/6847966)

    JAVA异步nio Java 线程池 System 阻塞队列

  • [

    java使用队列实现异步 java异步任务队列框架

    ExecutorCompletionService源码从上面的例子可以看到使用ExecutorCompletionService有三个关键步骤：设置一个线程池、submit提交任务、take获取完成的Future。看源码首先看他的属性，查看源码得到他有两个关键属性：Executor executor：执行线程的线程池;BlockingQueue completionQueue：阻塞队列，保存完成的

    ](https://blog.51cto.com/u_16213656/7577310)

    java使用队列实现异步 java异步任务库 阻塞队列 线程池 子类

  • [

    java 创建消息队列 java消息队列异步处理任务

    　　Java编程开发好入门吗？消息队列的用途有哪些？消息队列是指能够提供消息排队消费功能的软件程序，是消息队列中间件的一部分。消息队列中间件是分布式系统中重要的组件。接下来就给大家讲解消息队列的优势、类型以及使用场景。 　　消息队列的用途：　　主要解决应用解耦、异步消息、流量削锋等问题，实现高性能、高可用、可伸缩和最终一致性架构。　　消息队列的常见类型　　1、Kafka：由Apach

    ](https://blog.51cto.com/u_92655/7544378)

    java 创建消息队列 java异步处理 java消息队列 消息队列 Java

  • [

    java 主流 消息队列 java消息队列异步处理任务

    一 简介（1）异步消息：所谓异步消息，跟RMI远程调用、webservice调用是类似的，异步消息也是用于应用程序之间的通信。但是它们之间的区别是：RMI、Hession/Burlap、webservice等远程调用机制是同步的。也就是说，当客户端调用远程方法时，客户端必须等到远程方法响应后才能继续执行异步消息，顾名思义消息是异步发送，消息发送者不需要等待消息消费者处理消息，甚至不需要等待消息投递

    ](https://blog.51cto.com/u_16099347/7377960)

    java 主流 消息队列 java 测试 json 客户端

  • [

    java 异步多任务队列 java实现异步执行

    一、?前言异步执行对于开发者来说并不陌生，在实际的开发过程中，很多场景多会使用到异步，相比同步执行，异步可以大大缩短请求链路耗时时间，比如：发送短信、邮件、异步更新等，这些都是典型的可以通过异步实现的场景。二、异步的八种实现方式线程ThreadFuture异步框架CompletableFutureSpring注解@AsyncSpring ApplicationEvent事件消息队列第三方异步框架，

    ](https://blog.51cto.com/u_16099236/6336763)

    线程池 Async System

  • [

    java springbooot异步任务 springboot异步处理

    Spring Boot 提供了多种方式来实现异步任务，这里介绍三种主要实现方式。Spring Boot 提供了多种方式来实现异步任务，这里介绍三种实现方式。1、基于注解 @Async@Async 注解是 Spring 提供的一种轻量级异步方法实现方式，它可以标记在方法上，用来告诉 Spring 这个方法是一个异步方法，Spring 会将这个方法的执行放在异步线程中进行。使用 @Async 注解需要

    ](https://blog.51cto.com/u_16213656/7197579)

    spring boot spring java 异步任务 Async

  • [

    java的异步通知 java异步处理任务

    通常同步意味着一个任务的某个处理过程会对多个线程在用串行化处理，而异步则意味着某个处理过程可以允许多个线程同时处理。下面我们就来看看有关异步处理的详细内容。异步通常代表着更好的性能，因为它很大程度上依赖于缓冲，是典型的使用空间换时间的做法，例如在计算机当中，高速缓存作为cpu和磁盘io之间的缓冲地带协调cpu高速计算能力和磁盘的低速读写能力。volatile应用场景：检查一个应用执行关闭或中断状态

    ](https://blog.51cto.com/u_16099343/6340314)

    java 队列异步处理 服务器 应用场景 主线程

  • [

    java 分布式异步任务框架 java异步任务队列框架

    1. CompletableFutureCompletableFuture 是JDK1.8版本新引入的类。主要作用就是进行任务的异步计算，通过函数式接口的方式帮助我们简化了异步计算的复杂性。适用场景当你的业务处理中需要对部分处理异步计算，且最终汇总计算结果时，CompletableFuture是你不二的选择。JDK1.5中也提供了Future接口，但是获取结果需要一直让CPU轮询，同时配合线程或者

    ](https://blog.51cto.com/u_16213611/7505030)

    java 分布式异步任务框架 java 多线程 线程池 异步任务

  • [

    python bins什么意思 python bind

    入职前有关Pybind的学习，用时接近一天，终于把这块拿下了，心累！！！必须记录下来！ 一、pybind相关基本知识 pybind11是一个轻量级的仅头文件库，是一个只有标题的库，因此不需要链接任何特殊的库，主要用于创建现有C++代码的Python绑定。可将pybind11库视为Boost.Python的一个小型自包含版本，其中剥离了与绑定生成无关的所有内容，依赖于python(2.7或3.5+)

    ](https://blog.51cto.com/u_16099281/7737929)

    python bins什么意思 pycharm python visual studio Python

  • [

    python中的向量初始化 python向量机

    　　支持向量机（Support Vector Machine，SVM）的基本模型是定义在特征空间上间隔最大的线性分类器。它是一种二类分类模型，当采用了核技巧之后，支持向量机可以用于非线性分类。　　1）线性可分支持向量机（也称硬间隔支持向量机）：当训练数据线性可分是，通过硬间隔最大化，学得一个线性可分支持向量机　　2）线性支持向量机（也称为软间隔支持向量机）：当训练数据近似线性可分时，通过软间隔最大

    ](https://blog.51cto.com/u_16213679/7738158)

    python中的向量初始化 支持向量机 核函数 决策函数

  • [

    mss系统架构 msb架构

    时隔一个月又回到了博客园写文章，很开心O(∩_∩)O~~今天在做需求的涉及到一个固件版本的概念，其中固件组的人谈到了版本号从MSB到LSB排列，检索查阅后将所得整理如下。 MSB、LSB?MSB(Most Significant Bit)：最高有效位，二进制中代表最高值的比特位，这一位对数值的影响最大。LSB(Least Significant Bit)：最低有效位，二进制中代表最低值的

    ](https://blog.51cto.com/u_16099318/7741367)

    mss系统架构 网络 java linux python

  • [

    spark on yarn属于哪种架构 spark on yarn原理

    Spark on YARN工作原理 MapReduce on YARN的工作流程：加载数据，执行map，shuffle，reduce，将结果写入持久化存储。Spark on YARN的工作流程：spark中一个job包含多个stage，而非只有map和reduce，application包含多个job。 Spark工作原理用户通过spark-sumbi

    ](https://blog.51cto.com/u_16213584/7741652)

    spark on yarn属于哪种架构 spark 工作原理 工作流程

  • [

    数学建模神经网络模型建立及求解模板 神经网络 数学模型

    我见过的最脑残也是最好懂的人工神经网络算法教程你要的这份文档，原名为《用平常语言介绍神经网络》(NeuralNetworksinPlainEnglish)，有人翻译过来，做成文档供大家学习。人工神经网络是一种应用类似于大脑神经突触联接的结构进行信息处理的数学模型。在工程与学术界也常直接简称为神经网络或类神经网络。神经网络是一种运算模型，由大量的节点（或称神经元）之间相互联接构成。每个节点代表一种特

    ](https://blog.51cto.com/u_16099277/7744187)

    数学建模神经网络模型建立及求解模板 神经网络 机器学习 算法 人工智能

本文转自 https://blog.51cto.com/u_16099196/7662954，如有侵权，请联系删除。

赏

~~谢谢你请我吃糖果~~

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
C后端开发、Java后端开发、
开源爱好者、嵌入式爱好者、Linux内核、
操作系统原理

QQ:532182407
Email:[email protected]
By jimoying