jetty continuation基本原理及实现

最新推荐文章于 2017-08-05 10:37:26 发布
最新推荐文章于 2017-08-05 10:37:26 发布
阅读量1.9w 收藏 7
点赞数 1
分类专栏： jetty 文章标签： 任务 asynchronous redis interface object io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pwlazy/article/details/7299719
版权

背景

在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
  3. 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
    • 最后调用_request._async.unhandle()，AsyncContinuation实例的状态__ASYNCSTARTED-->__ASYNCWAIT
      • 会将suspend的那个请求任务放入selector线程的超时队列（和redis 事件框架的做法非常类似）
    • 为了简单期间，假设在上诉过程中，耗时操作还没完成，此时worker线程A被回收将会服务其他请求，虽然当前请求并未完成
  5. 匿名应用线程（在jetty woker线程另外启动的线程）完成耗时操作
    • 调用AsyncContinuation.resume() ,此时AsyncContinuation实例的状态__ASYNCWAIT-->__REDISPATCH
    • 然后会往worker线程队列或者selector线程队列中添加一个请求task，以此来触发jetty再次完成未完成的请求
  7. worker线程B再次处理那个请求
    • 流程进入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线程队列
  5. worker线程C处理超时任务
    • 调用AsyncContinuation.expired() ，此时AsyncContinuation实例的状态__ASYNCWAIT-->__REDISPATCH
    • 然后会往worker线程队列或者selector线程队列中添加一个请求task，以此来触发jetty再次完成未完成的请求
  7. 同上面的4

  • 具体流程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​
  4. 匿名应用线程（在jetty woker线程另外启动的线程）完成耗时操作，在2)中调用_request._async.unhandle()之前完成
    • 调用AsyncContinuation.resume() ,此时AsyncContinuation实例的状态__ASYNCSTARTED-->__REDISPATCHING
  6. 还是那个work线程A，注意此时3已经完成
    • 调用_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任务
此例子在jetty7.2和jetty7.6中测试通过，但在jetty8中运行失败（因为调用flush导致request中_header为空从而引发NPE[jetty8的bug?]，但如果不掉用有达不大展示效果）



pwlazy
关注
专栏目录
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
dvlinker的技术专栏
08-04 1万+
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
jetty，tomcat原理
08-25
1. **线程模型**：Jetty采用了一种称为"Continuation"的非阻塞I/O模型，它允许服务器在等待资源（如数据库查询）时释放线程，从而提高了并发性能。 2. **模块化设计**：Jetty由一系列小型模块组成，可以根据需要...
Jetty cometd(Continuation)学习笔记
06-29
Jetty是一个纯Java实现的开源Servlet容器，Jetty也可以作为HTTP服务器和HTTP客户端，Jetty仪器轻巧，稳定和高性能而著称，完全可以胜任企业级Servlet容器的要求。Jetty允许Apache Licence 2.0或者Eclipse Public License 1.0双重许可。您可以再遵循上述任何一个许可的基础上将Jetty用于各种商业用途。 Jetty 7是Jetty奔向Eclipse后发布的第一个版本，本次的Jetty 7 RC2带给了我们一个十分诱人的新特性-支持跨域名Ajax请求。众所周知因为安全的原因，多数浏览器都限制了Ajax跨域请求和javascript加载的时候只能是与当前域下的应用进行交互。
Jetty Continuation机制
kobejayandy的专栏
10-01 3437
Continuation机制 Continuation机制是Jetty用于更好的支持异步Servlet的机制。 首先简要介绍一下技术应用的背景。异步请求是指当客户端发送一个请求到服务器的时候，客户端不必一直等待服务器的响应，例如Web 2.0中的Ajax(Asynchronous JavaScript and XML)技术、JDBC连接池等，当服务器端响应返回时，客户端利用一个 Javasc
Jetty 的 Continuation 机制
yypiao的专栏
08-08 144
<转自http://www.ibm.com/developerworks/cn/web/wa-lo-jetty/> 简介： Jetty 是一个用 Java 实现、开源、基于标准的，并且具有丰富功能的 Http 服务器和 Web 容器，可以免费的用于商业行为。Jetty 这个项目成立于 1995 年，现在已经有非常多的成功产品基于 Jetty，比如 Apache Geromino，...
Comet & Jetty Continuations
kobejayandy的专栏
09-30 2519
Comet是一种服务器端推的技术，所谓服务器端推也就是当有事件要通知给某个用户的时候，是由服务器端直接发送到用户的浏览器。服务器端Push目前一般有两种方式，HTTP streaming和Long polling。
jetty 8及依赖包
05-12
这个压缩包包含Jetty 8版本的实现及其依赖库，是学习和理解Jetty工作原理，尤其是NIO（非阻塞I/O）和Servlet容器实现的宝贵资源。 Jetty 8在设计时特别强调了性能和可扩展性，它使用了Java NIO（New I/O）API来处理...
jetty 源码 2018 zip
05-04
6. **Continuation**：Jetty提供了对Servlet 3.0中Continuation接口的支持，允许开发者在处理长连接和异步操作时暂停和恢复请求。 7. **WebSocket**：Jetty提供了对WebSocket协议的支持，允许创建低延迟、双向通信...
jetty 架构
05-24
6. **Continuation**：Jetty提供了Continuation API，用于处理异步请求。当处理某个请求需要等待外部事件时，如数据库查询结果，可以暂停请求并恢复处理，提高响应速度。 7. **部署和生命周期管理**：Jetty提供了...
jetty-6.1.26.zip
04-04
Jetty是一款轻量级、高性能的Java Web服务器和Servlet容器，与Tomcat相似，它为开发和...尽管现代开发可能更倾向于使用更新的版本，但对于了解Jetty的历史和原理，以及在某些场景下部署旧项目，这个版本仍有其价值。
jetty-continuation-7.4.2.v20110526.jar
08-01
jetty-continuation-7.4.2.v20110526.jar jetty 服务jar包
jetty continuation
mxy2002924的专栏
04-25 183
下面的链接  解释了jetty 的长链接的实现原理： request,reposnse 的重入.   jetty的continuation是用于异步处理请求，简单的讲，请求模型不再是一请求一线程，而是在请求的过程中，可以挂起当前请求，用该容器线程处理别的请求。减小请求线程数，从而减少内存占用和上下文切换。还可以使得应用对于请求更可控，比如针对不同优先级请求分别排队等。 servlet3中也...
Jetty Continuation基本原理及实现
kobejayandy的专栏
09-21 2107
背景 在io密集型的web 应用，如何能更好地提升后台性能，jetty continuation是一个选择 现在特别流行的说法就是事件驱动，看看node.js以及redis, jetty continuation也不例外 一个例子 [java] view plaincopy package org.kaka.web;    im
Jetty Continuation源码分析
kobejayandy的专栏
09-21 2671
1.概述 jetty的continuation是用于异步处理请求，简单的讲，请求模型不再是一请求一线程，而是在请求的过程中，可以挂起当前请求，用该容器线程处理别的请求。减小请求线程数，从而减少内存占用和上下文切换。还可以使得应用对于请求更可控，比如针对不同优先级请求分别排队等。 servlet3中也有该异步请求的支持：http://docs.oracle.com/javaee/6/api/ja
Jetty 7 Continuation 总结
不是做计算机的料，不过一直在努力
12-19 187
最近开始研究jetty 7。已经出到稳定版了。我相信大多JETTY的爱好者已经看过了。 这里呢。对jetty 7的continuation总结一下。 为了做一个server long push的WEB应用。我选择了jetty。对于Jetty，我只能说是一个新手，在网上搜资料的时候，发现相关资料少个可怜，中文的资料都是一个抄一个，或者就是翻译的。对于jetty我走了弯路。迫使自己看是看jet...
jetty Continuations 就实现了上述异步方式--eclipse feature链接
yupei6699的专栏
08-05 416
http://wiki.eclipse.org/Jetty/Feature/Continuations
Netty，Jetty实现原理是什么
最新发布
06-08
Netty和Jetty都是Java中常用的网络通信库，它们的实现原理如下： 1. Netty Netty是一个基于事件驱动的异步网络通信库，它采用NIO（非阻塞IO）模型实现高性能的网络通信。Netty的主要特点包括： - 基于NIO模型，实现高性能的网络通信； - 采用事件驱动的方式，支持异步IO操作； - 提供了丰富的编解码器和处理器，方便用户进行网络通信协议的实现； - 支持多种网络协议，如TCP、UDP、HTTP、WebSocket等。 Netty的实现原理主要包括以下几个方面： - Reactor模式：Netty采用Reactor模式作为底层通信框架，通过Selector轮询IO事件，然后分发给对应的Handler进行处理； - Channel和EventLoop：Netty中的Channel表示一个网络连接，EventLoop表示一个事件循环，一个EventLoop可以对应多个Channel，通过事件驱动的方式进行异步IO操作； - Pipeline机制：Netty中的Pipeline是一种处理器链，每个Channel都有一个对应的Pipeline，通过添加不同的处理器，可以实现对网络通信数据的编解码、处理等操作； - ByteBuf：Netty中的ByteBuf是一种高效的字节缓冲区，支持读写操作，可以减少内存拷贝和提高IO效率。 2. Jetty Jetty是一个基于Servlet容器的Web服务器和Servlet容器，它采用线程池和NIO模型实现高性能的Web服务。Jetty的主要特点包括： - 基于Servlet容器，支持常用的Web应用开发技术； - 支持异步Servlet和WebSocket等技术，提高Web应用的性能和交互效果； - 支持HTTP/2和WebSocket协议，提升Web应用的传输效率； - 支持多种Web容器集群部署方式，提高Web应用的可伸缩性。 Jetty的实现原理主要包括以下几个方面： - Servlet容器：Jetty采用Servlet容器作为底层通信框架，通过处理HTTP请求和响应来实现Web服务； - 线程池和NIO模型：Jetty采用线程池和NIO模型实现高性能的Web服务，通过异步IO操作来提高Web应用的吞吐量； - WebSocket和HTTP/2支持：Jetty支持WebSocket和HTTP/2协议，提高Web应用的传输效率和交互效果； - Web容器集群：Jetty支持多种Web容器集群部署方式，提高Web应用的可伸缩性。 总的来说，Netty和Jetty都是高性能的网络通信库，它们实现原理的核心都是采用了NIO模型和事件驱动的方式来实现异步IO操作。Netty主要用于实现网络通信协议，如TCP、UDP、HTTP、WebSocket等，而Jetty主要用于实现Web服务器和Servlet容器。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值