背景

在io密集型的web 應用，如何能更好地提升後臺效能，jetty continuation是一個選擇

現在特別流行的說法就是事件驅動，看看node.js以及redis, 

jetty continuation也不例外

一個例子

package org.kaka.web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.continuation.Continuation;
import org.eclipse.jetty.continuation.ContinuationSupport;

public class SimpleSuspendResumeServlet extends HttpServlet {

	/**
	 * 
	 */
	private static final long serialVersionUID = 6112996063962978130L;

	private MyAsyncHandler myAsyncHandler;

	public void init() throws ServletException {

		myAsyncHandler = new MyAsyncHandler() {
			public void register(final MyHandler myHandler) {
				new Thread(new Runnable() {
					public void run() {
						try {
							Thread.sleep(10000);
							myHandler.onMyEvent("complete!");
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}

					}
				}).start();
			}
		};

	}

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// if we need to get asynchronous results
		//Object results = request.getAttribute("results");
		final PrintWriter writer = response.getWriter();
		final Continuation continuation = ContinuationSupport
				.getContinuation(request);
		//if (results == null) {
		if (continuation.isInitial()) {
			
			//request.setAttribute("results","null");
			sendMyFirstResponse(response);
			// suspend the request
			continuation.suspend(); // always suspend before registration

			// register with async service. The code here will depend on the
			// the service used (see Jetty HttpClient for example)
			myAsyncHandler.register(new MyHandler() {
				public void onMyEvent(Object result) {
					continuation.setAttribute("results", result);
					
					continuation.resume();
				}
			});
			return; // or continuation.undispatch();
		}

		if (continuation.isExpired()) {
			sendMyTimeoutResponse(response);
			return;
		}
		 //Send the results
		Object results = request.getAttribute("results");
		if(results==null){
			response.getWriter().write("why reach here??");
			continuation.resume();
			return;
		}
		sendMyResultResponse(response, results);
	}

	private interface MyAsyncHandler {
		public void register(MyHandler myHandler);
	}

	private interface MyHandler {
		public void onMyEvent(Object result);
	}
	
	private void sendMyFirstResponse(HttpServletResponse response) throws IOException {
		//必須加上這一行，否者flush也沒用，為什麼？
		response.setContentType("text/html");
		response.getWriter().write("start");
		response.getWriter().flush();

	}

	private void sendMyResultResponse(HttpServletResponse response,
			Object results) throws IOException {
		//response.setContentType("text/html");
		response.getWriter().write("results:" + results);
		response.getWriter().flush();

	}

	private void sendMyTimeoutResponse(HttpServletResponse response)
			throws IOException {
		response.getWriter().write("timeout");

	}

}
 

出於演示的目的，這個例子格外簡單。模擬了在web請求中如何處理一個耗時阻塞10s的io操作

• 常規的程式遇到這種情況（假設沒有設定超時），通常會等待10s，執行緒會白白浪費在哪，一旦請求一多，執行緒池及等待佇列會滿掉，從而導致網站無法服務
• 稍微好點的程式恐怕會使用futuretask來解決問題，但無論怎樣，futuretask帶有輪詢的性質，或多或少會帶有阻塞
• jetty continuation更進了一步， 採用事件驅動的方式來通知請求完成，絲毫不浪費一點io時間，一旦遇到阻塞，當前worker執行緒會結束，這樣就可以服務其他請求，等耗時操作處理完畢通知jetty,此時jetty會再動用一個新的worker執行緒再次處理請求

常見流程

• 具體流程1，耗時操作在AsyncContinuation預設超時（30s，可以設定)之內完成

1. 當請求到來，被selector執行緒感知

•  selector執行緒，會例項化org.eclipse.jetty.server.Request以及org.eclipse.jetty.server.AsyncContinuation
  
• AsyncContinuation例項此時狀態為__IDLE
  

• 流程進入org.eclipse.jetty.server.AsyncHttpConnection(AbstractHttpConnection).handleRequest()
  
• 呼叫_request._async.handling()，AsyncContinuation例項的狀態__IDLE-->__DISPATCHED
• 呼叫真正的業務邏輯server.handle(this);業務邏輯中呼叫AsyncContinuation.suspend(ServletContext, ServletRequest, ServletResponse) ,會將AsyncContinuation例項的狀態__DISPATCHED-->__ASYNCSTARTED
• 最後呼叫_request._async.unhandle()，AsyncContinuation例項的狀態__ASYNCSTARTED-->__ASYNCWAIT
  
  • 會將suspend的那個請求任務放入selector執行緒的超時佇列（和redis 事件框架的做法非常類似）
• 為了簡單期間，假設在上訴過程中，耗時操作還沒完成，此時worker執行緒A被回收將會服務其他請求，雖然當前請求並未完成

• 呼叫AsyncContinuation.resume() ,此時AsyncContinuation例項的狀態__ASYNCWAIT-->__REDISPATCH
  
• 然後會往worker執行緒佇列或者selector執行緒佇列中新增一個請求task，以此來觸發jetty再次完成未完成的請求

• 流程進入org.eclipse.jetty.server.AsyncHttpConnection(AbstractHttpConnection).handleRequest()
• 呼叫_request._async.handling()，AsyncContinuation例項的狀態__REDISPATCH-->__REDISPATCHED
  
• 呼叫server.handleAsync(this);再次進入業務邏輯，此時耗時操作已完成，可以輸出最後的結果
• 呼叫_request._async.unhandle()   AsyncContinuation例項的狀態__REDISPATCHED-->__UNCOMPLETED
• 呼叫_request._async.doComplete()，AsyncContinuation例項的狀態__UNCOMPLETED-->__COMPLETED 
  
• 請求結束

• 具體流程2，耗時操作超過了AsyncContinuation預設超時時間

1. 同上
   
2. 同上
3. selector執行緒輪詢中感知到耗時任務超時

• 此時在輪詢中能感知並獲取這個task,見org.eclipse.jetty.io.nio.SelectorManager$SelectSet.doSelect()
  
• 將此task丟入worker執行緒佇列
  

• 呼叫AsyncContinuation.expired() ，此時AsyncContinuation例項的狀態__ASYNCWAIT-->__REDISPATCH
  
• 然後會往worker執行緒佇列或者selector執行緒佇列中新增一個請求task，以此來觸發jetty再次完成未完成的請求
  

• 具體流程3，耗時操作非常快

1. 同上
   
2. worker執行緒A會獲取到selector執行緒派發的這個請求
   

• 流程進入org.eclipse.jetty.server.AsyncHttpConnection(AbstractHttpConnection).handleRequest()
  
• 呼叫_request._async.handling()，AsyncContinuation例項的狀態__IDLE-->__DISPATCHED
  
• 呼叫真正的業務邏輯server.handle(this);業務邏輯中呼叫AsyncContinuation.suspend(ServletContext, ServletRequest, ServletResponse) ,會將AsyncContinuation例項的狀態__DISPATCHED-->__ASYNCSTARTED​

• 呼叫AsyncContinuation.resume() ,此時AsyncContinuation例項的狀態__ASYNCSTARTED-->__REDISPATCHING

• 呼叫_request._async.unhandle()，，AsyncContinuation例項的狀態__REDISPATCHING-->__REDISPATCHED
  
• 由於此時_request._async.unhandle()返回false,再次進入迴圈呼叫server.handleAsync(this);再次進入業務邏輯，此時耗時操作已完成，可以輸出最後的結果
  
• 呼叫_request._async.unhandle()   AsyncContinuation例項的狀態__REDISPATCHED-->__UNCOMPLETED
  
• 呼叫_request._async.doComplete()，AsyncContinuation例項的狀態__UNCOMPLETED-->__COMPLETED
• 請求結束 

小結

總體來講

• jetty continuation需要在應用中使用應用級的執行緒池來完成一些io任務，這個在普通的web程式設計並不常見
  
• 在應用的第一次請求中需要
  • 呼叫AsyncContinuation.suspend（完成一個狀態的轉換，以及產生一個超時任務）
  • 將耗時任務派發給應用執行緒池
  • 完畢後，jetty回收該請求執行緒
• io任務在應用執行緒中完成後，然後通過AsyncContinuation.resume或者complete等方法通知jetty任務完成
• jetty然後會再次分配一個worker執行緒處理該請求（如果邏輯複雜，如並行的多次Io會分配多個worker執行緒）
• 引入jetty continuation帶來的負面作用是程式設計模型會變得複雜，需要仔細的切割各類io任務