Servlet3.0异步编程与SSE

Servlet异步编程

在Servlet 3.0之前，Servlet采用Thread-Per-Request的方式处理请求。即每一次Http请求都由某一个线程从头到尾负责处理。

如果一个请求需要进行IO操作，比如访问数据库、调用第三方服务接口等，那么其所对应的线程将同步地等待IO操作完成， 而IO操作是非常慢的，所以此时的线程并不能及时地释放回线程池以供后续使用，在并发量越来越大的情况下，这将带来严重的性能问题。

即便是像Spring、Struts这样的高层框架也脱离不了这样的桎梏，因为他们都是建立在Servlet之上的。为了解决这样的问题，Servlet 3.0引入了异步处理，然后在Servlet 3.1中又引入了非阻塞IO来进一步增强异步处理的性能。

在Servlet 3.0中，我们可以从HttpServletRequest对象中获得一个AsyncContext对象，该对象构成了异步处理的上下文，Request和Response对象都可从中获取。AsyncContext可以从当前线程传给另外的线程，并在新的线程中完成对请求的处理并返回结果给客户端，初始线程便可以还回给容器线程池以处理更多的请求。如此，通过将请求从一个线程传给另一个线程处理的过程便构成了Servlet 3.0中的异步处理。

一个简单的示例：

@WebServlet(value = "/simple", asyncSupported = true)
public class SimpleServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        AsyncContext asyncContext = request.startAsync();
        long t1 = System.currentTimeMillis();
        asyncContext.start(() -> {
            try {
                //模拟耗时操作
                TimeUnit.SECONDS.sleep(5);

                asyncContext.getResponse().getWriter().write("Hello World!");
            } catch (Exception e) {
                e.printStackTrace();
            }
            asyncContext.complete();
        });
//        CompletableFuture.runAsync(() -> {
//            try {
//                //模拟耗时操作
//                TimeUnit.SECONDS.sleep(5);
//
//                asyncContext.getResponse().getWriter().write("Hello World!");
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            asyncContext.complete();
//        });
        System.out.println("async use:" + (System.currentTimeMillis() - t1));
    }
}

注意的地方：

1. @WebServlet注解需要加上asyncSupported = true，以支持异步请求
2. 程序打印async use的值为0，说明Servlet主线程几乎没有被占用（响应很快），然而客户端需要等待新的线程中完成对请求的处理并返回，所以客户端仍需等待5秒。
3. AsyncContext的start()方法会向Servlet容器另外申请一个新的线程（可以是从Servlet容器中已有的主线程池获取，也可以另外维护一个线程池，不同容器实现可能不一样），然后在这个新的线程中继续处理请求，而原先的线程将被回收到主线程池中。处理完毕后需要调用complete()方法告知Servlet容器

除了调用AsyncContext的start()方法，我们还可以通过手动创建线程池的方式来实现异步处理：

@WebServlet(value = "/simple", asyncSupported = true)
public class SimpleServlet extends HttpServlet {

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(100, 200, 50000L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100));

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        AsyncContext asyncContext = request.startAsync();
        long t1 = System.currentTimeMillis();
        executor.execute(() -> {
            try {
                //模拟耗时操作
                TimeUnit.SECONDS.sleep(5);

                asyncContext.getResponse().getWriter().write("Hello World!");
            } catch (Exception e) {
                e.printStackTrace();
            }
            asyncContext.complete();
        });
        System.out.println("async use:" + (System.currentTimeMillis() - t1));
    }
}

Servlet 3.0对请求的处理虽然是异步的，但是对InputStream和OutputStream的IO操作却依然是阻塞的，对于数据量大的请求体或者返回体，阻塞IO也将导致不必要的等待。

因此在Servlet 3.1中引入了非阻塞IO，通过在HttpServletRequest和HttpServletResponse中分别添加ReadListener和WriterListener方式，只有在IO数据满足一定条件时（比如数据准备好时），才进行后续的操作。

@WebServlet(value = "/NonBlockingServlet", asyncSupported = true)
public class NonBlockingServlet extends HttpServlet {
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(100, 200, 50000L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100));
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        AsyncContext asyncContext = request.startAsync();
        long t1 = System.currentTimeMillis();
        ServletInputStream inputStream = request.getInputStream();
        //为ServletInputStream添加了一个ReadListener
        inputStream.setReadListener(new ReadListener() {
            @Override
            public void onDataAvailable() throws IOException {

            }

            @Override
            public void onAllDataRead() throws IOException {
                executor.execute(()->{
                    // 模拟耗时操作
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
                    }

                    try {
                        asyncContext.getResponse().getWriter().write("hello world!");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    asyncContext.complete();
                });
            }

            @Override
            public void onError(Throwable t) {
                asyncContext.complete();
            }
        });
        System.out.println("async use:" + (System.currentTimeMillis() - t1));

    }
}

SSE(Sever-Sent Event)

SSE与Servlet异步编程并无什么关系，所谓SSE，就是浏览器向服务器发送一个HTTP请求，保持长连接，服务器不断单向地向浏览器推送“信息”（message），类似WebSockt，也是H5的新特性。

SSE和WebSocket相比一个轻量级协议，SSE是单向通道，只能服务器向浏览器端发送。最大的优势是便利，服务端不需要其他的类库，开发难度较低。SSE和轮询相比它不用处理很多请求，不用每次建立新连接，延迟较低。

看一个简单示例：

@WebServlet(value = "/sse")
@Slf4j
public class SSEServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/event-stream");
        response.setCharacterEncoding("utf-8");
		while(true){
	        PrintWriter pw=response.getWriter();
	        try {
	            Thread.sleep(1000);
	            pw.write("data:"+new Date() + "\r\n");
	            pw.flush();              
	        }catch (Exception e) {
	            e.printStackTrace();
	        }
        }
    }
}

当以sse的方式返回数据时，首先需要设置response的contentType，然后把数据写到response里（注意格式），并用flush()方法输出。这样就实现了客户端只发送一次请求，服务器不断地单向推送消息，保持长连接。

如果长连接过程中客户端被关闭了，服务端没有感知却还在执行这个循环，这种情况显然是不允许的。关闭浏览器后，服务器下一次要推送时就会抛出异常，这个异常已经在PrintWriter的flush()中被捕捉了，我们只需它的调用checkError()，有错误的话return即可停止执行。

@WebServlet(value = "/sse")
@Slf4j
public class SSEServlet extends HttpServlet {

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/event-stream");
        response.setCharacterEncoding("utf-8");

        PrintWriter pw=response.getWriter();
        while (true){
            try {
                Thread.sleep(1000);
                pw.write("data:"+new Date() + "\r\n");
//                pw.flush();
                if (pw.checkError()) { //checkError方法中调用flush方法
                    String str = "客户端断开连接";
                    log.info("结果：{}", str);
                    return;
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

上面服务端不断的向客户端推送消息，一直占据着Servlet主线程，这不是我们想要的，结合上述的Servlet异步编程，我们可以进行如下的优化：

@WebServlet(value = "/sse", asyncSupported = true)
@Slf4j
public class SSEServlet extends HttpServlet {

	private static ThreadPoolExecutor executor = new ThreadPoolExecutor(100, 200, 50000L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100));

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/event-stream");
        response.setCharacterEncoding("utf-8");

        AsyncContext asyncContext = request.startAsync();
        asyncContext.setTimeout(10 * 60 * 1000); //设置AsyncContext的超时时间，默认30秒，0或者负值表示不超时
        executor.execute(()->{doSomething(asyncContext);});

        System.out.println("end!");
    }

    private void doSomething(AsyncContext asyncContext) {
        ServletResponse response = asyncContext.getResponse();

        try {
            PrintWriter pw=response.getWriter();
            while (true){
                Thread.sleep(1000);
                pw.write("data:"+new Date() + "\r\n");
//                pw.flush();
//                asyncContext.complete();
                if (pw.checkError()) {
                    String str = "客户端断开连接";
                    log.info("结果：{}", str);
                    return;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }
    }
}

Spring Boot 2 之 Webflux 反应式编程解析及实战