Servlet 3.0非同步特性初探
Servlet 是 Java 為了編寫服務端程式而定義的一個介面規範，在 Servlet 3.0 以後支援了非同步的操作。
最近專案添加了一個程式碼熱部署的功能，在客戶端輸入訊號，訊號到達 Web 伺服器後，需要 Web 伺服器將訊號以 UDP 的方式遞送給另外一個閘道器伺服器，閘道器伺服器再以同樣的通訊方式返回訊號，最後在返回給客戶端。如圖。
說到非同步，自然會聯想到它的對立『同步』。作業系統的知識告訴我們，非同步/同步實際上是指的一種訊息通訊機制。
由於在專案中 Web 伺服器接受 UDP 訊號是使用的非同步執行緒，所以必須要使用到 Servlet 的非同步特性，這是一個原因。
傳統的 Servlet 規範中，一個 Web 伺服器（即 Servlet 容器）同時會接收到多個 HTTP 請求，其中一個請求對應一個執行緒處理，這個處理執行緒會涉及到業務邏輯處理，甚至是資料庫查詢，這些都是很費時的。
如果使用傳統的 Servlet 同步規範，舉個極端的例子：一個 Tomcat 伺服器最多同時支援 150 個併發請求，假設一個請求加上邏輯處理和資料庫操作一次耗時 5s ，如果在 5s 內同時有 150 個人發來了 HTTP 請求，這時 Tomcat 的處理能力正好滿足需求，如果這時候需要做程式碼的熱部署，再向 Web 服傳送 HTTP 請求的話，那麼就會造成等待。
綜合上面兩個因素，不得不使用到 Servlet 的非同步特性。
首先就是非同步 Servlet 中最重要的一個介面 AsyncContext，它的原始碼如下：
public interface AsyncContext {
//獲得一次請求中的 request 物件
public ServletRequest getRequest();
//獲得一次請求中的 response 物件
public ServletResponse getResponse();
//檢查 AsyncContext 是否由原生的 request 和 response 物件初始化生成
public boolean hasOriginalRequestAndResponse();
//
public void dispatch();
//
public void dispatch(String path);
//
public void dispatch(ServletContext context, String path);
//將由 request 開啟的非同步操作設定為完成狀態, 並關閉 response
public void complete();
//呼叫此方法, Servlet 容器會分發一個執行緒來執行傳進來的 Runnable 任務, 並且會向 Runnable 任務中傳入必要的上下文資訊, 即開啟一個非同步週期
public void start(Runnable run);
//把指定的非同步監聽 AsyncListner 註冊到 AsyncContext 中, 在一個非同步週期中任何的 complete, time out, error 事件都會被監聽器監聽
public void addListener(AsyncListener listener);
public void addListener(AsyncListener listener, ServletRequest servletRequest, ServletResponse servletResponse);
public <T extends AsyncListener> T createListener(Class<T> clazz) throws ServletException;
//為開啟的非同步週期設定超時時間, 如果不手動設定, 容器會為我們設定一個預設的超時時間
public void setTimeout(long timeout);
//
public long getTimeout();
}
在上面提到了非同步監聽器 AsyncListner，下面來看看這個監聽器的介面規範是什麼樣的：
public interface AsyncListener extends EventListener {
public void onComplete(AsyncEvent event) throws IOException;
public void onTimeout(AsyncEvent event) throws IOException;
public void onError(AsyncEvent event) throws IOException;
public void onStartAsync(AsyncEvent event) throws IOException;
}
傳入一個 AsyncEvent 非同步事件，來完成各種監聽。觀察 AsyncEvent 原始碼知道這個非同步事件的構成：
public class AsyncEvent {
private AsyncContext context;
private ServletRequest request;
private ServletResponse response;
private Throwable throwable;
public AsyncEvent(AsyncContext context, ServletRequest request, ServletResponse response, Throwable throwable) {
this.context = context;
this.request = request;
this.response = response;
this.throwable = throwable;
}
}
之所以在非同步事件裡保管 request 和 response 的引用，是因為需要通過觸發的非同步事件對客戶端進行響應，要進行響應自然要用到 response 物件。
下面通過一個例子來看一看 非同步 Servlet 規範到底如何使用：
public class LoadClassServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
System.out.println(" Start Servlet " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
System.out.println(" doPost() Thread Name : " + Thread.currentThread().getName());
System.out.println( " In doPost " + request);
System.out.println( " In doPost " + response);
request.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);
//開啟非同步週期
AsyncContext asyncContext = request.startAsync();
asyncContext.setTimeout(10*1000);
asyncContext.start(new Runnable() {
@Override
public void run() {
try {
System.out.println(" run() Thread Name : " + Thread.currentThread().getName());
//模擬啟用執行緒非同步遞送訊號, 一般來說是一些耗時的操作
System.out.println(" Before Sleep " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
Thread.sleep(5 * 1000);
System.out.println(" After Sleep " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
asyncContext.complete();
System.out.println(" After complete() " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
System.out.println( " In AsyncContext " + asyncContext.getRequest() );
System.out.println( " In AsyncContext " + asyncContext.getResponse() );
asyncContext.addListener( new AsyncListener() {
@Override
public void onTimeout(AsyncEvent event) throws IOException {
///////////////////////////////////////
//這個方法內一般會寫一些關於超時的邏輯
//假設10s還沒有收到返回的訊號, 就將錯誤訊息
//在這裡通過response物件返回給客戶端
///////////////////////////////////////
System.out.println(" onTimeout() " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
event.getSuppliedResponse().getWriter().println(" timeout ");
}
@Override
public void onStartAsync(AsyncEvent event) throws IOException {
System.out.println(" onStartAsync() ");
}
@Override
public void onError(AsyncEvent event) throws IOException {
System.out.println(" onError() ");
}
@Override
public void onComplete(AsyncEvent event) throws IOException {
/////////////////////////////
//這個方法無論怎樣都會被呼叫
//不管是手動呼叫complete()方法
//還是超時, 這個方法都會被執行
/////////////////////////////
System.out.println(" onComplete() " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
System.out.println(" onComplete() Thread Name : " + Thread.currentThread().getName());
System.out.println( " In AsyncEvent "+event.getSuppliedRequest() );
System.out.println( " In AsyncEvent "+event.getSuppliedResponse() );
event.getSuppliedResponse().getWriter().println(" complete ");
}
} );
System.out.println( " End of Servlet " + DateUtil.getDefaultFormatDate(System.currentTimeMillis()));
}
}
首先只打開關於 request 和 response 物件的列印語句，在瀏覽器請求此 Servlet，擷取相關的輸出如下：
In doPost org.apache.catalina.connector.RequestFacade@4500c794In doPost org.apache.catalina.connector.ResponseFacade@307fd18d In AsyncContext org.apache.catalina.connector.RequestFacade@4500c794In AsyncContext org.apache.catalina.connector.ResponseFacade@307fd18d In AsyncEvent org.apache.catalina.connector.RequestFacade@4500c794In AsyncEvent org.apache.catalina.connector.ResponseFacade@307fd18d
可以看到 3 個地方的打印出來的 request 和 response 物件都是同一個。
為了方便控制檯瀏覽，現在將所有 request 和 response 的列印都註釋掉。
為了弄清楚非同步 Servlet 的執行流程，觀察四種情況下的控制檯列印情況。
< 1 > 休眠時間為 5s，休眠結束後立即呼叫 complete() 方法
請求 Servlet，控制檯列印如下：
Start Servlet 2018-10-27 18:57:20doPost() Thread Name : http-nio-8080-exec-7run() Thread Name : http-nio-8080-exec-1Before Sleep 2018-10-27 18:57:20End of Servlet 2018-10-27 18:57:20After Sleep 2018-10-27 18:57:25After complete() 2018-10-27 18:57:25onComplete() 2018-10-27 18:57:25onComplete() Thread Name : http-nio-8080-exec-8
瀏覽器輸出為：
非同步操作執行 5s 後，手動呼叫 complete() 方法，onCmplete() 監聽方法被執行，並向瀏覽器輸出 complete 字串，這是一種情況。
< 2 >休眠時間改為 15s，休眠結束後立即呼叫 complete() 方法
請求 Servlet，控制檯列印如下：
Start Servlet 2018-10-27 18:59:09doPost() Thread Name : http-nio-8080-exec-2run() Thread Name : http-nio-8080-exec-4Before Sleep 2018-10-27 18:59:09End of Servlet 2018-10-27 18:59:09onTimeout() 2018-10-27 18:59:20onComplete() 2018-10-27 18:59:20onComplete() Thread Name : http-nio-8080-exec-5After Sleep 2018-10-27 18:59:24
瀏覽器輸出為：
< 3 > 休眠時間為 5s，休眠結束後不呼叫complete()方法
請求 Servlet，控制檯列印如下：
Start Servlet 2018-10-27 19:10:42doPost() Thread Name : http-nio-8080-exec-2run() Thread Name : http-nio-8080-exec-3Before Sleep 2018-10-27 19:10:42End of Servlet 2018-10-27 19:10:42After Sleep 2018-10-27 19:10:47onTimeout() 2018-10-27 19:10:53onComplete() 2018-10-27 19:10:53onComplete() Thread Name : http-nio-8080-exec-4
瀏覽器輸出為：
< 4 > 休眠時間為 15s，休眠結束後不呼叫complete()方法
請求 Servlet，控制檯列印如下：
Start Servlet 2018-10-27 19:13:11doPost() Thread Name : http-nio-8080-exec-3run() Thread Name : http-nio-8080-exec-7Before Sleep 2018-10-27 19:13:11End of Servlet 2018-10-27 19:13:11onTimeout() 2018-10-27 19:13:22onComplete() 2018-10-27 19:13:22onComplete() Thread Name : http-nio-8080-exec-5After Sleep 2018-10-27 19:13:26
瀏覽器輸出為：
分析四種列印結果，得出以下幾個結論：
- 監聽器的 onComplete 方法無論怎樣都會執行，要麼是呼叫 AsyncContext#complete 方法後執行，要麼是超時時間到了自動執行。
- 只有在設定的 Timeout 時間內呼叫 AsyncContext#complete 方法才不會觸發 onTimeout 方法，其餘情況都會被觸發執行。
- 另外有趣的一點是，執行過程中出現了 3 個不同的執行緒，分別是：處理 HTTP 請求的執行緒；非同步執行模擬遞送訊號的執行緒（非同步執行緒也可以使用自己建立的執行緒）；執行回撥監聽方法的執行緒
在實際應用中，一般不會像上面例子那樣使用 Web 容器為我們分配的執行緒。從上面的列印就能看出，在 Tomcat 的實現中，呼叫 AsyncContex#start() 後，預設使用的的非同步執行緒是處理 HTTP 請求的執行緒，這樣雖然能達到非同步的目的，但是對於提高請求的併發量沒起到作用。
所以一般的做法是，自己維護一個非同步處理的執行緒池，維護的執行緒數量一般大於 Web 容器用來處理 HTTP 請求的執行緒數。這樣既能實現非同步操作，又能提高 HTTP 請求處理的併發量。
（完）