12.异步请求知识点与使用姿势小结

在Servlet3.0就引入了异步请求的支持，但是在实际的业务开发中，可能用过这个特性的童鞋并不多？

本篇博文作为异步请求的扫盲和使用教程，将包含以下知识点

• 什么是异步请求，有什么特点，适用场景
• 四种使用姿势：
  • AsyncContext方式
  • Callable
  • WebAsyncTask
  • DeferredResult

I. 异步请求

异步对于我们而言，应该属于经常可以听到的词汇了，在实际的开发中多多少少都会用到，那么什么是异步请求呢

1. 异步请求描述

先介绍一下同步与异步：

一个正常调用，吭哧吭哧执行完毕之后直接返回，这个叫同步；

接收到调用，自己不干，新开一个线程来做，主线程自己则去干其他的事情，等后台线程吭哧吭哧的跑完之后，主线程再返回结果，这个就叫异步

异步请求：

我们这里讲到的异步请求，主要是针对web请求而言，后端响应请求的一种手段，同步/异步对于前端而言是无感知、无区别的

同步请求，后端接收到请求之后，直接在处理请求线程中，执行业务逻辑，并返回

来源于网络

异步请求，后端接收到请求之后，新开一个线程，来执行业务逻辑，释放请求线程，避免请求线程被大量耗时的请求沾满，导致服务不可用

来源于网络

2. 特点

通过上面两张图，可以知道异步请求的最主要特点

• 业务线程，处理请求逻辑
• 请求处理线程立即释放，通过回调处理线程返回结果

3. 场景分析

从特点出发，也可以很容易看出异步请求，更适用于耗时的请求，快速的释放请求处理线程，避免web容器的请求线程被打满，导致服务不可用

举一个稍微极端一点的例子，比如我以前做过的一个多媒体服务，提供图片、音视频的编辑，这些服务接口有同步返回结果的也有异步返回结果的；同步返回结果的接口有快有慢，大部分耗时可能<10ms，而有部分接口耗时则在几十甚至上百

这种场景下，耗时的接口就可以考虑用异步请求的方式来支持了，避免占用过多的请求处理线程，影响其他的服务

II. 使用姿势

接下来介绍四种异步请求的使用姿势，原理一致，只是使用的场景稍有不同

1. AsyncContext

在Servlet3.0+之后就支持了异步请求，第一种方式比较原始，相当于直接借助Servlet的规范来实现，当然下面的case并不是直接创建一个servlet，而是借助AsyncContext来实现

@RestController
@RequestMapping(path = "servlet")
public class ServletRest {

    @GetMapping(path = "get")
    public void get(HttpServletRequest request) {
        AsyncContext asyncContext = request.startAsync();
        asyncContext.addListener(new AsyncListener() {
            @Override
            public void onComplete(AsyncEvent asyncEvent) throws IOException {
                System.out.println("操作完成:" + Thread.currentThread().getName());
            }

            @Override
            public void onTimeout(AsyncEvent asyncEvent) throws IOException {
                System.out.println("超时返回!!!");
                asyncContext.getResponse().setCharacterEncoding("utf-8");
                asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                asyncContext.getResponse().getWriter().println("超时了！！！!");
            }

            @Override
            public void onError(AsyncEvent asyncEvent) throws IOException {
                System.out.println("出现了m某些异常");
                asyncEvent.getThrowable().printStackTrace();

                asyncContext.getResponse().setCharacterEncoding("utf-8");
                asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                asyncContext.getResponse().getWriter().println("出现了某些异常哦！！！!");
            }

            @Override
            public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
                System.out.println("开始执行");
            }
        });

        asyncContext.setTimeout(3000L);
        asyncContext.start(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(Long.parseLong(request.getParameter("sleep")));
                    System.out.println("内部线程：" + Thread.currentThread().getName());
                    asyncContext.getResponse().setCharacterEncoding("utf-8");
                    asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                    asyncContext.getResponse().getWriter().println("异步返回!");
                    asyncContext.getResponse().getWriter().flush();
                    // 异步完成，释放
                    asyncContext.complete();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        System.out.println("主线程over!!! " + Thread.currentThread().getName());
    }
}

完整的实现如上，简单的来看一下一般步骤

• javax.servlet.ServletRequest#startAsync()获取AsyncContext
• 添加监听器 asyncContext.addListener(AsyncListener)（这个是可选的）
  • 用户请求开始、超时、异常、完成时回调
• 设置超时时间 asyncContext.setTimeout(3000L) （可选）
• 异步任务asyncContext.start(Runnable)

2. Callable

相比较于上面的复杂的示例，SpringMVC可以非常easy的实现，直接返回一个Callable即可

@RestController
@RequestMapping(path = "call")
public class CallableRest {

    @GetMapping(path = "get")
    public Callable<String> get() {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("do some thing");
                Thread.sleep(1000);
                System.out.println("执行完毕，返回!!!");
                return "over!";
            }
        };

        return callable;
    }


    @GetMapping(path = "exception")
    public Callable<String> exception() {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("do some thing");
                Thread.sleep(1000);
                System.out.println("出现异常，返回!!!");
                throw new RuntimeException("some error!");
            }
        };

        return callable;
    }
}

请注意上面的两种case，一个正常返回，一个业务执行过程中，抛出来异常

分别请求，输出如下

# http://localhost:8080/call/get
do some thing
执行完毕，返回!!!

异常请求: http://localhost:8080/call/exception

do some thing
出现异常，返回!!!
2020-03-29 16:12:06.014 ERROR 24084 --- [nio-8080-exec-5] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] threw exception

java.lang.RuntimeException: some error!
	at com.git.hui.boot.async.rest.CallableRest$2.call(CallableRest.java:40) ~[classes/:na]
	at com.git.hui.boot.async.rest.CallableRest$2.call(CallableRest.java:34) ~[classes/:na]
	at org.springframework.web.context.request.async.WebAsyncManager.lambda$startCallableProcessing$4(WebAsyncManager.java:328) ~[spring-web-5.2.1.RELEASE.jar:5.2.1.RELEASE]
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) ~[na:1.8.0_171]
	at java.util.concurrent.FutureTask.run$$$capture(FutureTask.java:266) ~[na:1.8.0_171]
	at java.util.concurrent.FutureTask.run(FutureTask.java) ~[na:1.8.0_171]
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) ~[na:1.8.0_171]
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) ~[na:1.8.0_171]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_171]

3. WebAsyncTask

callable的方式，非常直观简单，但是我们经常关注的超时+异常的处理却不太好，这个时候我们可以用WebAsyncTask，实现姿势也很简单，包装一下callable，然后设置各种回调事件即可

@RestController
@RequestMapping(path = "task")
public class WebAysncTaskRest {

    @GetMapping(path = "get")
    public WebAsyncTask<String> get(long sleep, boolean error) {
        Callable<String> callable = () -> {
            System.out.println("do some thing");
            Thread.sleep(sleep);

            if (error) {
                System.out.println("出现异常，返回!!!");
                throw new RuntimeException("异常了!!!");
            }

            return "hello world";
        };

        // 指定3s的超时
        WebAsyncTask<String> webTask = new WebAsyncTask<>(3000, callable);
        webTask.onCompletion(() -> System.out.println("over!!!"));

        webTask.onTimeout(() -> {
            System.out.println("超时了");
            return "超时返回!!!";
        });

        webTask.onError(() -> {
            System.out.println("出现异常了!!!");
            return "异常返回";
        });

        return webTask;
    }
}

4. DeferredResult

DeferredResult与WebAsyncTask最大的区别就是前者不确定什么时候会返回结果，

DeferredResult的这个特点，可以用来做实现很多有意思的东西，如后面将介绍的SseEmitter就用到了它

下面给出一个实例

@RestController
@RequestMapping(path = "defer")
public class DeferredResultRest {

    private Map<String, DeferredResult> cache = new ConcurrentHashMap<>();

    @GetMapping(path = "get")
    public DeferredResult<String> get(String id) {
        DeferredResult<String> res = new DeferredResult<>();
        cache.put(id, res);

        res.onCompletion(new Runnable() {
            @Override
            public void run() {
                System.out.println("over!");
            }
        });
        return res;
    }

    @GetMapping(path = "pub")
    public String publish(String id, String content) {
        DeferredResult<String> res = cache.get(id);
        if (res == null) {
            return "no consumer!";
        }

        res.setResult(content);
        return "over!";
    }
}

在上面的实例中，用户如果先访问http://localhost:8080/defer/get?id=yihuihui，不会立马有结果，直到用户再次访问http://localhost:8080/defer/pub?id=yihuihui&content=哈哈时，前面的请求才会有结果返回

那么这个可以设置超时么，如果一直把前端挂住，貌似也不太合适吧

• 在构造方法中指定超时时间: new DeferredResult<>(3000L)
• 设置全局的默认超时时间

@Configuration
@EnableWebMvc
public class WebConf implements WebMvcConfigurer {

    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        // 超时时间设置为60s
        configurer.setDefaultTimeout(TimeUnit.SECONDS.toMillis(10));
    }
}

II. 其他

0. 项目

相关博文

• 007-优化web请求三-异步调用【WebAsyncTask】
• 高性能关键技术之---体验Spring MVC的异步模式（Callable、WebAsyncTask、DeferredResult） 基础使用篇

系列博文

• 200105-SpringBoot系列web篇之自定义返回Http-Code的n种姿势
• 191222-SpringBoot系列教程web篇之自定义请求匹配条件RequestCondition
• 191206-SpringBoot系列教程web篇Listener四种注册姿势
• 191122-SpringBoot系列教程web篇Servlet 注册的四种姿势
• 191120-SpringBoot系列教程Web篇之开启GZIP数据压缩
• 191018-SpringBoot系列教程web篇之过滤器Filter使用指南扩展篇
• 191016-SpringBoot系列教程web篇之过滤器Filter使用指南
• 191012-SpringBoot系列教程web篇之自定义异常处理HandlerExceptionResolver
• 191010-SpringBoot系列教程web篇之全局异常处理
• 190930-SpringBoot系列教程web篇之404、500异常页面配置
• 190929-SpringBoot系列教程web篇之重定向
• 190913-SpringBoot系列教程web篇之返回文本、网页、图片的操作姿势
• 190905-SpringBoot系列教程web篇之中文乱码问题解决
• 190831-SpringBoot系列教程web篇之如何自定义参数解析器
• 190828-SpringBoot系列教程web篇之Post请求参数解析姿势汇总
• 190824-SpringBoot系列教程web篇之Get请求参数解析姿势汇总
• 190822-SpringBoot系列教程web篇之Beetl环境搭建
• 190820-SpringBoot系列教程web篇之Thymeleaf环境搭建
• 190816-SpringBoot系列教程web篇之Freemaker环境搭建
• 190421-SpringBoot高级篇WEB之websocket的使用说明
• 190327-Spring-RestTemplate之urlencode参数解析异常全程分析
• 190317-Spring MVC之基于java config无xml配置的web应用构建
• 190316-Spring MVC之基于xml配置的web应用构建
• 190213-SpringBoot文件上传异常之提示The temporary upload location xxx is not valid

源码

• 工程：https://github.com/liuyueyi/spring-boot-demo
• 项目源码: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/219-web-asyn