详解Spring/Spring boot异步任务编程WebAsyncTask

时间：2022-09-21 22:22:33

今天一起学习下如何在spring中进行异步编程。我们都知道，web服务器处理请求 request 的线程是从线程池中获取的，这也不难解释，因为当web请求并发数非常大时，如何一个请求进来就创建一条处理线程，由于创建线程和线程上下文切换的开销是比较大的，web服务器最终将面临崩溃。另外，web服务器创建的处理线程从头到尾默认是同步执行的，也就是说，假如处理线程a负责处理请求b，那么当b没有 return 之前，处理线程a是不可以脱身去处理别的请求的，这将极大限制了web服务器的并发处理能力。

因此线程池解决了线程可循环利用的问题，那同步处理请求怎么去解决呢？答案是异步处理。什么是异步处理呢？异步处理主要是让上面的b请求处理完成之前，能够将a线程空闲出来继续去处理别的请求。那么我们可以这样做，在a线程内部重新开启一个线程c去执行任务，让a直接返回给web服务器，继续接受新进来的请求。

在开始下面的讲解之前，我在这里先区别下两个概念：

1、处理线程

处理线程属于web服务器，负责处理用户请求，采用线程池管理

2、异步线程

异步线程属于用户自定义的线程，可采用线程池管理

spring中提供了对异步任务的支持，采用 webasynctask 类即可实现异步任务，同时我们也可以对异步任务设置相应的回调处理，如当任务超时、抛出异常怎么处理等。异步任务通常非常实用，比如我们想让一个可能会处理很长时间的操作交给异步线程去处理，又或者当一笔订单支付完成之后，开启异步任务查询订单的支付结果。

一、正常异步任务

为了演示方便，异步任务的执行采用 thread.sleep(long) 模拟，现在假设用户请求以下接口 :

http://localhost:7000/demo/getuserwithnothing.json

异步任务接口定义如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 测试没有发生任何异常的异步任务
 */
@requestmapping(value = "getuserwithnothing.json", method = requestmethod.get)
public webasynctask<string> getuserwithnothing() {
 // 打印处理线程名
 system.err.println("the main thread name is " + thread.currentthread().getname());
 
 // 此处模拟开启一个异步任务,超时时间为10s
 webasynctask<string> task1 = new webasynctask<string>(10 * 1000l, () -> {
    system.err.println("the first thread name is " + thread.currentthread().getname());
    // 任务处理时间5s,不超时
    thread.sleep(5 * 1000l);
    return "任务1顺利执行成功！任何异常都没有抛出！";
 });
 
 // 任务执行完成时调用该方法
 task1.oncompletion(() -> {
    system.err.println("任务1执行完成啦！");
 });
 
 system.err.println("task1继续处理其他事情！");
 return task1;
}

控制台打印如下：

the main thread name is http-nio-7000-exec-1
task1继续处理其他事情！
the first thread name is mvcasync1
任务1执行完成啦！

浏览器结果如下：

 

 
详解Spring/Spring boot异步任务编程WebAsyncTask 

 

二、抛异常异步任务

接口调用 ： http://localhost:7000/demo/getuserwitherror.json

?
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
28
29
30
31
32
/**
 * 测试发生error的异步任务
 * @return
 */
@requestmapping(value = "getuserwitherror.json", method = requestmethod.get)
public webasynctask<string> getuserwitherror() {
    system.err.println("the main thread name is " + thread.currentthread().getname());
 
    // 此处模拟开启一个异步任务
    webasynctask<string> task3 = new webasynctask<string>(10 * 1000l, () -> {
        system.err.println("the second thread name is " + thread.currentthread().getname());
        // 此处抛出异常
        int num = 9 / 0;
        system.err.println(num);
        return "";
    });
 
    // 发生异常时调用该方法
    task3.onerror(() -> {
        system.err.println("====================================" + thread.currentthread().getname()
                + "==============================");
        system.err.println("任务3发生error啦！");
        return "";
    });
    // 任务执行完成时调用该方法
    task3.oncompletion(() -> {
        system.err.println("任务3执行完成啦！");
    });
 
    system.err.println("task3继续处理其他事情！");
    return task3;
}

控制台输出如下：

the main thread name is http-nio-7000-exec-1
task3继续处理其他事情！
the second thread name is mvcasync1
2018-06-15 09:40:13.538 error 9168 --- [nio-7000-exec-2] o.a.c.c.c.[.[.[.[dispatcherservlet] : servlet.service() for servlet [dispatcherservlet] threw exception

java.lang.arithmeticexception: / by zero
at com.example.demo.controller.getuserinfocontroller.lambda$5(getuserinfocontroller.java:93) ~[classes/:na]
at org.springframework.web.context.request.async.webasyncmanager.lambda$startcallableprocessing$4(webasyncmanager.java:317) ~[spring-web-5.0.6.release.jar:5.0.6.release]
at java.util.concurrent.executors$runnableadapter.call(executors.java:511) ~[na:1.8.0_161]
at java.util.concurrent.futuretask.run(futuretask.java:266) ~[na:1.8.0_161]
at java.lang.thread.run(thread.java:748) [na:1.8.0_161]

2018-06-15 09:40:13.539 error 9168 --- [nio-7000-exec-2] o.a.c.c.c.[.[.[.[dispatcherservlet] : servlet.service() for servlet [dispatcherservlet] in context with path [/demo] threw exception [request processing failed; nested exception is java.lang.arithmeticexception: / by zero] with root cause

java.lang.arithmeticexception: / by zero
at com.example.demo.controller.getuserinfocontroller.lambda$5(getuserinfocontroller.java:93) ~[classes/:na]
at org.springframework.web.context.request.async.webasyncmanager.lambda$startcallableprocessing$4(webasyncmanager.java:317) ~[spring-web-5.0.6.release.jar:5.0.6.release]
at java.util.concurrent.executors$runnableadapter.call(executors.java:511) ~[na:1.8.0_161]
at java.util.concurrent.futuretask.run(futuretask.java:266) ~[na:1.8.0_161]
at java.lang.thread.run(thread.java:748) [na:1.8.0_161]

====================================http-nio-7000-exec-2==============================
任务3发生error啦！
任务3执行完成啦！

当然你也可以对上面做一些异常处理，不至于在用户看来显得不友好，关于异常处理，可以查看我的另一篇文章 spring boot/spring 统一错误处理方案的使用

浏览器输出结果：

 

 
详解Spring/Spring boot异步任务编程WebAsyncTask 

 

三、超时异步任务

接口调用 ： http://localhost:7000/demo/getuserwithtimeout.json

?
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
28
29
30
/**
 * 测试发生任务超时的异步任务
 * @return
 */
@requestmapping(value = "getuserwithtimeout.json", method = requestmethod.get)
public webasynctask<string> getuserwithtimeout() {
 system.err.println("the main thread name is " + thread.currentthread().getname());
 
 // 此处模拟开启一个异步任务,超时10s
 webasynctask<string> task2 = new webasynctask<string>(10 * 1000l, () -> {
    system.err.println("the second thread name is " + thread.currentthread().getname());
    thread.sleep(20 * 1000l);
    return "任务2执行超时！";
 });
 
 // 任务超时调用该方法
 task2.ontimeout(() -> {
    system.err.println("====================================" + thread.currentthread().getname()
            + "==============================");
    return "任务2发生超时啦！";
 });
 
 // 任务执行完成时调用该方法
 task2.oncompletion(() -> {
    system.err.println("任务2执行完成啦！");
 });
 
 system.err.println("task2继续处理其他事情！");
 return task2;
}

控制台执行结果：

the main thread name is http-nio-7000-exec-4
task2继续处理其他事情！
the second thread name is mvcasync2
====================================http-nio-7000-exec-5==============================
任务2执行完成啦！

浏览器执行结果：

 

 
详解Spring/Spring boot异步任务编程WebAsyncTask 

 

四、线程池异步任务

上面的三种情况中的异步任务默认不是采用线程池机制进行管理的，也就是说，一个请求进来，虽然释放了处理线程，但是系统依旧会为每个请求创建一个异步任务线程，也就是上面我们看到的 mvcasync 开头的异步任务线程，那这样不行啊，开销特别大呀！所以我们可以采用线程池进行管理，直接在 webasynctask 类构造器传入一个 threadpooltaskexecutor 对象实例即可。

下面我们先看看，当对上面第一种情况执行并发请求时会出现什么情况(此处模拟对 http://localhost:7000/demo/getuserwithnothing.json 进行并发调用)：

控制台输出如下：

the first thread name is mvcasync57
the first thread name is mvcasync58
the first thread name is mvcasync59
the first thread name is mvcasync60
the first thread name is mvcasync61
the first thread name is mvcasync62
the first thread name is mvcasync63
the first thread name is mvcasync64
the first thread name is mvcasync65
the first thread name is mvcasync66
the first thread name is mvcasync67
the first thread name is mvcasync68
the first thread name is mvcasync69
the first thread name is mvcasync70
the first thread name is mvcasync71
the first thread name is mvcasync72
the first thread name is mvcasync73
the first thread name is mvcasync74
the first thread name is mvcasync76
the first thread name is mvcasync75
the first thread name is mvcasync77
the first thread name is mvcasync78
the first thread name is mvcasync79
the first thread name is mvcasync80

由于没有加入线程池，所以100个请求将开启100个异步任务线程，开销特别大，不推荐。

下面是采用线程池的实现 ：

调用接口 ： http://localhost:7000/demo/getuserwithexecutor.json

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * 测试线程池
 * @return
 */
@requestmapping(value = "getuserwithexecutor.json", method = requestmethod.get)
public webasynctask<string> getuserwithexecutor() {
 system.err.println("the main thread name is " + thread.currentthread().getname());
 
 // 此处模拟开启一个异步任务,此处传入一个线程池
 webasynctask<string> task1 = new webasynctask<string>(10 * 1000l, executor, () -> {
    system.err.println("the first thread name is " + thread.currentthread().getname());
    thread.sleep(5000l);
    return "任务4顺利执行成功！任何异常都没有抛出！";
 });
 
 // 任务执行完成时调用该方法
 task1.oncompletion(() -> {
    system.err.println("任务4执行完成啦！");
 });
 
 system.err.println("task4继续处理其他事情！");
 return task1;
}

线程池定义如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@configuration
public class myexecutor {
 
 @bean
 public static threadpooltaskexecutor getexecutor() {
    threadpooltaskexecutor taskexecutor = new threadpooltaskexecutor();
    taskexecutor.setcorepoolsize(30);
    taskexecutor.setmaxpoolsize(30);
    taskexecutor.setqueuecapacity(50);
    taskexecutor.setthreadnameprefix("huang");// 异步任务线程名以 huang 为前缀
    return taskexecutor;
 }
}

对上面进行并发测试，可以得出下面结果 :

详解Spring/Spring boot异步任务编程WebAsyncTask

本文示例代码地址： https://github.com/smallercoder/webasynctask

采用线程池可以节约服务器资源，优化服务器处理能力，要记得常用哟！谢谢阅读！觉得对你有帮助，请给个start哦！

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://juejin.im/post/5b230edde51d4558bc58bc14

标签：

相关文章