Servlet 异步处理

web容器会为每个请求分配一个线程，Servlet3.0新增了异步处理，解决多个线程不释放占据内存的问题。可以先释放容器分配给请求的线程与相关资源，减轻系统负担，原先释放了容器所分配线程的请求，其响应将被延后，可以在处理完成后再对客户端进行响应。

一、AsyncContex简介

    为了支持异步处理，在ServletRequest上提供了startAsync()方法。可以通过AsyncContext的getRequest()和getResponse()方法取得请求、响应对象，此次对客户端的响应将暂缓至调用AsyncContext的complete()或dispatch()方法为止。

    首先要告知此容器支持Servlet异步处理，如：

  1: @WebServlet(urlPatterns="/some.do", asyncSupported = true)
  2: public class AsyncServlet extends HttpServlet{
  3: 
  4: }

    例1：异步处理的例子

AsyncServlet.java

  1: package ServletAPI;
  2: 
  3: import java.io.IOException;
  4: import java.util.concurrent.ExecutorService;
  5: import java.util.concurrent.Executors;
  6: import javax.servlet.AsyncContext;
  7: import javax.servlet.ServletException;
  8: import javax.servlet.annotation.WebServlet;
  9: import javax.servlet.http.HttpServlet;
 10: import javax.servlet.http.HttpServletRequest;
 11: import javax.servlet.http.HttpServletResponse;
 12: 
 13: /**
 14:  * Servlet implementation class AsyncServlet
 15:  */
 16: @WebServlet(name = "AsyncServlet", urlPatterns = { "/async.do" },asyncSupported=true)
 17: public class AsyncServlet extends HttpServlet {
 18:     private static final long serialVersionUID = 1L;
 19:     private ExecutorService executorService=Executors.newFixedThreadPool(10);   
 20:     /**
 21:      * @see HttpServlet#HttpServlet()
 22:      */
 23:     public AsyncServlet() {
 24:         super();
 25:         // TODO Auto-generated constructor stub
 26:     }
 27: 
 28:     /**
 29:      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
 30:      */
 31:     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 32:       // TODO Auto-generated method stub
 33:       response.setContentType("text/html;charset=UTF-8");
 34:       AsyncContext ctx=request.startAsync();//开始异步处理，释放请求线程
 35:       executorService.submit(new AsynvRequest(ctx)); //创建AsyncRequest，调度线程
 36:     
 37:     }
 38: 
 39:     /**
 40:      * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
 41:      */
 42:     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 43:       // TODO Auto-generated method stub
 44:     }
 45:     public void destroy(){
 46:       executorService.shutdown();//关闭线程池
 47:     }
 48: 
 49: }
 50: 

    首先告诉容器，这个Servlet支持异步处理，对于每个请求，Servlet会取得其AsyncContext，并释放容器所分配的线程，响应被延迟后。对于这些被延迟后响应的请求，创建一个实现Runnable接口的AsyncRequest对象，并将其调度一个固定数量的线程池，让这些必须长时间处理的请求，在线程池中完成，不用每次分配线程。

    例2：AsyncRequest是个实现Runnable的类，其模拟了长时间处理。

AsyncRequest.java

  1: package ServletAPI;
  2: 
  3: import java.io.PrintWriter;
  4: import javax.servlet.AsyncContext;
  5: public class AsynvRequest implements Runnable{
  6:   private AsyncContext ctx;
  7: 
  8:   public AsynvRequest(AsyncContext ctx) {
  9:     super();
 10:     this.ctx = ctx;
 11:   }
 12: 
 13:   @Override
 14:   public void run() {
 15:     // TODO Auto-generated method stub
 16:     try {
 17:       Thread.sleep(10000);//模拟冗长请求
 18:       PrintWriter out=ctx.getResponse().getWriter();
 19:       out.println("久等了...XD");//输出结果
 20:       ctx.complete();//对客户端完成响应
 21:     } catch (Exception e) {
 22:       // TODO Auto-generated catch block
 23:       throw new RuntimeException(e);
 24:     }
 25:     
 26:   }
 27:   
 28: }
 29: 

    以暂停线程的方式来模拟长时间处理，并输出简单的文字，最后调用complete()对客户端完成响应。

二、模拟服务器推播

    HTTP是基于请求、响应模型，如果客户端要获得服务器的最新状态，就必须以定期方式发送请求，查询服务器端的最新状态。

    Servlet 3.0提供的异步处理技术，可以解决每个请求占用线程的问题，再结合Ajax异步请求技术，就可以达到类似服务器主动通知浏览器的行为。这就是所谓的服务器端推播。

    例3：模拟应用程序不定期产生最新数据，这个部分由实现ServletContextListener的类负责，会在程序启动时进行。

WebInitListener.java

  1: package ServletAPI;
  2: 
  3: import java.util.ArrayList;
  4: import java.util.List;
  5: import javax.servlet.AsyncContext;
  6: import javax.servlet.ServletContextEvent;
  7: import javax.servlet.ServletContextListener;
  8: import javax.servlet.annotation.WebListener
  9: 
 10: /**
 11:  * Application Lifecycle Listener implementation class WebInitListener
 12:  *
 13:  */
 14: @WebListener
 15: public class WebInitListener implements ServletContextListener {
 16:     private List<AsyncContext> asyncs=new ArrayList<>();//所有的异步请求AsyncContext将存储在这个List中。
 17: 
 18:     public void contextDestroyed(ServletContextEvent arg0) {
 19:         // TODO Auto-generated method stub
 20:     }
 21: 
 22:   /**
 23:      * @see ServletContextListener#contextInitialized(ServletContextEvent)
 24:      */
 25:     public void contextInitialized(ServletContextEvent arg0) {
 26:         // TODO Auto-generated method stub
 27:       new Thread(new Runnable(){
 28:         public void run(){
 29:           while(true){
 30:             try {//模拟产生随机数字
 31:             Thread.sleep((int)(Math.random()*10000));
 32:             double num=Math.random()*10;
 33:             synchronized (asyncs) {
 34:               for(AsyncContext ctx:asyncs){
 35:                 ctx.getResponse().getWriter().println(num);
 36:                 ctx.complete();
 37:               }
 38:             }
 39:           } catch (Exception e) {
 40:             // TODO Auto-generated catch block
 41:             throw new RuntimeException();
 42:           }
 43:           }
 44:         }
 45:       }).start();
 46:     }
 47:   
 48: }
 49: 

    有个List会存储所有的异步请求的AsyncContext，并在不定时产生数字后，逐一对客户端响应，并调用AsyncContext的conmplete()来完成请求。

    负责接收请求的Servlet，一收到请求，就将之加入到List中。

AsyncNumServlet.java

  1: package ServletAPI;
  2: 
  3: import java.io.IOException;
  4: import java.util.List;
  5: import javax.servlet.AsyncContext;
  6: import javax.servlet.ServletException;
  7: import javax.servlet.annotation.WebServlet;
  8: import javax.servlet.http.HttpServlet;
  9: import javax.servlet.http.HttpServletRequest;
 10: import javax.servlet.http.HttpServletResponse;
 11: 
 12: @WebServlet(name = "AsyncNumServlet", urlPatterns = { "/asyncNum.do" }, asyncSupported=true)
 13: public class AsyncNumServlet extends HttpServlet {
 14:     private static final long serialVersionUID = 1L;
 15:     private List<AsyncContext> asyncs; 
 16: 
 17:     public void init() throws ServletException{
 18:       asyncs=(List<AsyncContext>)getServletContext().getAttribute("asyncs");
 19:       
 20:     }
 21:     /**
 22:      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
 23:      */
 24:     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 25:       // TODO Auto-generated method stub
 26:       AsyncContext ctx=request.startAsync();//开始异步处理
 27:       synchronized (asyncs) {
 28:         asyncs.add(ctx);//加入维护AsyncContext的List中
 29:       }
 30:     }
 31: 
 32: }
 33: 

    由于List是储存为ServletContext属性，所以在Servlet中，必须从ServletContext中取出，每次请求到来时，调用HttpServletRequest的startAsync()进行异步处理，并取得AsyncContext加入维护AsyncContext的List中。

    可以使用一个简单的HTML，使用Ajax技术，发送异步请求值服务器端，这个请求会被延迟，直到服务器端完成响应后，更新网页上的资料，并再度发送异步请求：

async.html

  1: <!DOCTYPE html>
  2: <html>
  3: <head>
  4: <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
  5: <title>实时资料</title>
  6: <script>
  7:   function asyncUpdate(){
  8:     var xhr;
  9:     if(window.XMLHttpRequest){
 10:       xhr=new XMLHttpRequest();
 11:     }else
 12:     if(window.ActiveXObject){
 13:       xhr=new ActiveXObject('Microsoft.XMLHTTP');
 14:     }
 15:     xhr.onreadystatechange=function(){
 16:       if(xhr.readyState==4){
 17:         if(xhr.status==200){
 18:           document.getElementById("data").innerHTML=xhr.responseText;
 19:           asyncUpdate();
 20:         }
 21:       }
 22:     };
 23:     xhr.open('GET','asyncNum.do?timestamp='+new Date().getTime());
 24:     xhr.send(null);
 25:   }
 26:   window.onload=asyncUpdate;
 27: </script>
 28: </head>
 29: <body>
 30:   实时资料：<span id="data">0</span>
 31: </body>
 32: </html>

    可以试着用多个浏览器请求这个页面，会看到每个浏览器的资料是同步的。