异步Servlet

1. 异步操作

应用服务器中的Web容器通常对每个客户机请求使用一个服务器线程。在高负载条件下，容器需要大量线程来服务所有客户机请求。可伸缩性限制包括内存耗尽或耗尽容器线程池。要创建可伸缩的web应用程序，您必须确保与请求相关的线程没有闲置，以便容器可以使用它们来处理新请求。

Servlet 3.0引入了异步处理，然后在Servlet 3.1中又引入了非阻塞IO来进一步增强异步处理的性能。如果servlet或过滤器在处理请求时遇到潜在的阻塞操作，它可以将该操作分配给异步执行上下文，并立即将与该请求关联的线程返回给容器，而不生成响应。阻塞操作在异步执行上下文中的不同线程中完成，该线程可以生成响应或将请求分派给另一个servlet。

异步操作事例图如下：

 2. 事例

@WebServlet(urlPatterns = "/asyncTest", asyncSupported = true)
public class AsyncServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String time = req.getParameter("time");
        AsyncContext asyncContext = req.startAsync(req, resp);
        asyncContext.setTimeout(3000);
        asyncContext.start(() -> {
            // 模拟耗时操作
            try {
                Thread.sleep(Integer.parseInt(time));
                resp.getWriter().write("Async operation completed");
                asyncContext.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}

首先，要开启Servlet的异步支持:

@WebServlet(urlPatterns = "/asyncTest", asyncSupported = true)

然后通过HttpServletRequest的startAsync方法获取AsyncContext，接着调用start方法异步处理业务请求，完成调用complete方法。

AsyncContext asyncContext = req.startAsync(req, resp);

还可以设置异步超时时间，通过AsyncContext的setTimeOut来设置

看下上面事例的结果，业务处理时间为1000毫秒时，结果如下：

 业务处理时间为4000毫秒时，返回500，此时说明超时了

 3. 事例2

也可以使用线程池来处理业务，代码如下：

@WebServlet(urlPatterns = "/asyncTest", asyncSupported = true)
public class AsyncServlet extends HttpServlet {

    private ExecutorService executorService;

    @Override
    public void init() throws ServletException {
        executorService = Executors.newFixedThreadPool(3);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String time = req.getParameter("time");
        AsyncContext asyncContext = req.startAsync(req, resp);
        asyncContext.setTimeout(3000);
        executorService.submit(() -> {
            // 模拟耗时操作
            try {
                Thread.sleep(Integer.parseInt(time));
                resp.getWriter().write("Async operation completed");
                asyncContext.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}

4. 设置监听器

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String time = req.getParameter("time");
    AsyncContext asyncContext = req.startAsync(req, resp);
    asyncContext.setTimeout(3000);
    asyncContext.addListener(new AsyncListener() {
        @Override
        public void onComplete(AsyncEvent asyncEvent) throws IOException {
            System.out.println("onComplete");
        }

        @Override
        public void onTimeout(AsyncEvent asyncEvent) throws IOException {
            System.out.println("onTimeout");
        }

        @Override
        public void onError(AsyncEvent asyncEvent) throws IOException {
            System.out.println("onError");
        }

        @Override
        public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
            System.out.println("onStartAsync");
        }
    });
    executorService.submit(() -> {
        // 模拟耗时操作
        try {
            Thread.sleep(Integer.parseInt(time));
            resp.getWriter().write("Async operation completed");
            asyncContext.complete();
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
}

可以看到，在完成操作之后，输出了onComplete

5. 非阻塞IO

虽然Servlet 3.0规范让Servlet的执行变为了异步，但是其IO还是阻塞式的。IO阻塞是说，在Servlet处理请求时，从ServletInputStream中读取请求体时是阻塞的。而我们想要的是，当数据就绪时通知我们去读取就可以了，因为这可以避免占用Servlet容器线程或者业务线程来进行阻塞读。事例如下：

@WebServlet(urlPatterns = "/asyncTest2", asyncSupported = true)
public class NoBlockingAsyncServlet extends HttpServlet {
    private ExecutorService executorService;

    @Override
    public void init() throws ServletException {
        executorService = Executors.newFixedThreadPool(3);
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String time = req.getParameter("time");
        AsyncContext asyncContext = req.startAsync(req, resp);
        ServletInputStream inputStream = req.getInputStream();
        inputStream.setReadListener(new ReadListener() {
            @Override
            public void onDataAvailable() throws IOException {

            }

            @Override
            public void onAllDataRead() throws IOException {
                executorService.submit(() -> {
                    try {
                        Thread.sleep(Integer.parseInt(time));
                        resp.getWriter().write("noblocking async operation completed");
                        asyncContext.complete();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }

            @Override
            public void onError(Throwable throwable) {

            }
        });
    }
}