Servlet 3特性:异步Servlet
本文由 ImportNew - 彭秦进 翻译自 journaldev。欢迎加入翻译小组。转载请见文末要求。
理解异步Servlet之前,让我们试着理解为什么需要它。假设我们有一个Servlet需要很多的时间来处理,类似下面的内容:
LongRunningServlet.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
package com.journaldev.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet ( "/LongRunningServlet" )
public class LongRunningServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
long startTime = System.currentTimeMillis();
System.out.println( "LongRunningServlet Start::Name="
+ Thread.currentThread().getName() + "::ID="
+ Thread.currentThread().getId());
String time = request.getParameter( "time" );
int secs = Integer.valueOf(time);
// max 10 seconds
if (secs > 10000 )
secs = 10000 ;
longProcessing(secs);
PrintWriter out = response.getWriter();
long endTime = System.currentTimeMillis();
out.write( "Processing done for " + secs + " milliseconds!!" );
System.out.println( "LongRunningServlet Start::Name="
+ Thread.currentThread().getName() + "::ID="
+ Thread.currentThread().getId() + "::Time Taken="
+ (endTime - startTime) + " ms." );
}
private void longProcessing( int secs) {
// wait for given time before finishing
try {
Thread.sleep(secs);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
|
如果我们的URL是:http://localhost:8080/AsyncServletExample/LongRunningServlet?time=8000
得到响应为“Processing done for 8000 milliseconds! !“。现在,如果你会查看服务器日志,会得到以下记录:
1
2
|
LongRunningServlet Start::Name=http-bio-8080- exec -34::ID=103
LongRunningServlet Start::Name=http-bio-8080- exec -34::ID=103::Time Taken=8002 ms.
|
所以Servlet线程实际运行超过 8秒,尽管大多数时间用来处理其它Servlet请求或响应。
这可能导致线程饥饿——因为我们的Servlet线程被阻塞,直到所有的处理完成。如果服务器的请求得到了很多过程,它将达到最大Servlet线程限制和进一步的请求会拒绝连接错误。
Servlet 3.0之前,这些长期运行的线程容器特定的解决方案,我们可以产生一个单独的工作线程完成耗时的任务,然后返回响应客户。Servlet线程返回Servlet池后启动工作线程。Tomcat 的 Comet、WebLogic FutureResponseServlet 和 WebSphere Asynchronous Request Dispatcher都是实现异步处理的很好示例。
容器特定解决方案的问题在于,在不改变应用程序代码时不能移动到其他Servlet容器。这就是为什么在Servlet3.0提供标准的方式异步处理Servlet的同时增加异步Servlet支持。
实现异步Servlet
让我们看看步骤来实现异步Servlet,然后我们将提供异步支持Servlet上面的例子:
- 首先Servlet,我们提供异步支持 Annotation @WebServlet 的属性asyncSupported 值为true。
- 由于实际实现委托给另一个线程,我们应该有一个线程池实现。我们可以一个通过Executors framework 创建线程池和使用servlet context listener来初始化线程池。
- 通过ServletRequest.startAsync方法获取AsyncContext的实例。AsyncContext提供方法让ServletRequest和ServletResponse对象引用。它还提供了使用调度方法将请求转发到另一个 dispatch() 方法。
- 编写一个可运行的实现,我们将进行重处理,然后使用AsyncContext对象发送请求到另一个资源或使用ServletResponse编写响应对象。一旦处理完成,我们通过AsyncContext.complete()方法通知容器异步处理完成。
- 添加AsyncListener实现AsyncContext对象实现回调方法,我们可以使用它来提供错误响应客户端装进箱的错误或超时,而异步线程处理。在这里我们也可以做一些清理工作。
一旦我们将完成我们的项目对于异步Servlet示例,项目结构看起来会像下面的图片:
在监听中初始化线程池
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package com.journaldev.servlet.async;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
@WebListener
public class AppContextListener implements ServletContextListener {
public void contextInitialized(ServletContextEvent servletContextEvent) {
// create the thread pool
ThreadPoolExecutor executor = new ThreadPoolExecutor( 100 , 200 , 50000L,
TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>( 100 ));
servletContextEvent.getServletContext().setAttribute( "executor" ,
executor);
}
public void contextDestroyed(ServletContextEvent servletContextEvent) {
ThreadPoolExecutor executor = (ThreadPoolExecutor) servletContextEvent
.getServletContext().getAttribute( "executor" );
executor.shutdown();
}
}
|
实现很直接,如果你不熟悉ThreadPoolExecutor 框架请读线程池的ThreadPoolExecutor 。关于listeners 的更多细节,请阅读教程Servlet Listener。
工作线程实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
package com.journaldev.servlet.async;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.AsyncContext;
public class AsyncRequestProcessor implements Runnable {
private AsyncContext asyncContext;
private int secs;
public AsyncRequestProcessor() {
}
public AsyncRequestProcessor(AsyncContext asyncCtx, int secs) {
this .asyncContext = asyncCtx;
this .secs = secs;
}
@Override
public void run() {
System.out.println( "Async Supported? "
+ asyncContext.getRequest().isAsyncSupported());
longProcessing(secs);
try {
PrintWriter out = asyncContext.getResponse().getWriter();
out.write( "Processing done for " + secs + " milliseconds!!" );
} catch (IOException e) {
e.printStackTrace();
}
//complete the processing
asyncContext.complete();
}
private void longProcessing( int secs) {
// wait for given time before finishing
try {
Thread.sleep(secs);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
|
注意:在请求和响应时使用AsyncContext对象,然后在完成时调用 asyncContext.complete() 方法。
AsyncListener 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
package com.journaldev.servlet.async;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebListener;
@WebListener
public class AppAsyncListener implements AsyncListener {
@Override
public void onComplete(AsyncEvent asyncEvent) throws IOException {
System.out.println( "AppAsyncListener onComplete" );
// we can do resource cleanup activity here
}
@Override
public void onError(AsyncEvent asyncEvent) throws IOException {
System.out.println( "AppAsyncListener onError" );
//we can return error response to client
}
@Override
public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
System.out.println( "AppAsyncListener onStartAsync" );
//we can log the event here
}
@Override
public void onTimeout(AsyncEvent asyncEvent) throws IOException {
System.out.println( "AppAsyncListener onTimeout" );
//we can send appropriate response to client
ServletResponse response = asyncEvent.getAsyncContext().getResponse();
PrintWriter out = response.getWriter();
out.write( "TimeOut Error in Processing" );
}
}
|
通知的实现在 Timeout()方法,通过它发送超时响应给客户端。
Async Servlet 实现
这是我们的异步Servlet实现,注意使用AsyncContext和ThreadPoolExecutor进行处理。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
package com.journaldev.servlet.async;
import java.io.IOException;
import java.util.concurrent.ThreadPoolExecutor;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet (urlPatterns = "/AsyncLongRunningServlet" , asyncSupported = true )
public class AsyncLongRunningServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
long startTime = System.currentTimeMillis();
System.out.println( "AsyncLongRunningServlet Start::Name="
+ Thread.currentThread().getName() + "::ID="
+ Thread.currentThread().getId());
request.setAttribute( "org.apache.catalina.ASYNC_SUPPORTED" , true );
String time = request.getParameter( "time" );
int secs = Integer.valueOf(time);
// max 10 seconds
if (secs > 10000 )
secs = 10000 ;
AsyncContext asyncCtx = request.startAsync();
asyncCtx.addListener( new AppAsyncListener());
asyncCtx.setTimeout( 9000 );
ThreadPoolExecutor executor = (ThreadPoolExecutor) request
.getServletContext().getAttribute( "executor" );
executor.execute( new AsyncRequestProcessor(asyncCtx, secs));
long endTime = System.currentTimeMillis();
System.out.println( "AsyncLongRunningServlet End::Name="
+ Thread.currentThread().getName() + "::ID="
+ Thread.currentThread().getId() + "::Time Taken="
+ (endTime - startTime) + " ms." );
}
}
|
Run Async Servlet
现在,当我们将上面运行servlet URL:
http://localhost:8080/AsyncServletExample/AsyncLongRunningServlet?time=8000
得到响应和日志:
1
2
3
4
|
AsyncLongRunningServlet Start::Name=http-bio-8080- exec -50::ID=124
AsyncLongRunningServlet End::Name=http-bio-8080- exec -50::ID=124::Time Taken=1 ms.
Async Supported? true
AppAsyncListener onComplete
|
如果运行时设置time=9999,在客户端超时以后会得到响应超时错误处理和日志:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
AsyncLongRunningServlet Start::Name=http-bio-8080- exec -44::ID=117
AsyncLongRunningServlet End::Name=http-bio-8080- exec -44::ID=117::Time Taken=1 ms.
Async Supported? true
AppAsyncListener onTimeout
AppAsyncListener onError
AppAsyncListener onComplete
Exception in thread "pool-5-thread-6" java.lang.IllegalStateException: The request associated with the AsyncContext has already completed processing.
at org.apache.catalina.core.AsyncContextImpl.check(AsyncContextImpl.java:439)
at org.apache.catalina.core.AsyncContextImpl.getResponse(AsyncContextImpl.java:197)
at com.journaldev.servlet.async.AsyncRequestProcessor.run(AsyncRequestProcessor.java:27)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
at java.lang.Thread.run(Thread.java:680)
|
注意:Servlet线程执行完,很快就和所有主要的处理工作是发生在其他线程。
这是所有异步Servlet内容,希望你喜欢它。下载 AsyncServletExample 工程
原文链接: journaldev 翻译: ImportNew.com - 彭秦进
译文链接: http://www.importnew.com/8864.html
[ 转载请保留原文出处、译者和译文链接。]
关于作者: 彭秦进
转载于:https://www.cnblogs.com/clds/p/5006572.html
Servlet 3特性:异步Servlet相关推荐
- Servlet 3的异步Servlet功能
在深入了解什么是异步Servlet之前,让我们尝试了解为什么需要它. 假设我们有一个Servlet,处理时间很长,如下所示. LongRunningServlet.java package com.j ...
- servlet异步_关于Servlet和异步Servlet
servlet异步 Servlet API是Java EE标准的一部分,自1998年正式发布2.1规范以来,一直是基于Java的企业体系结构的重要组成部分. 它是一种自以为是的API,用于服务围绕一些 ...
- servlet异步_如何使用异步Servlet来提高性能
servlet异步 这篇文章将描述一种性能优化技术,该技术适用于与现代Web应用程序相关的常见问题. 如今的应用程序不再只是被动地等待浏览器发起请求,而是希望自己开始通信. 一个典型的示例可能涉及聊天 ...
- servlet 3.0异步_Servlet 3.0异步处理可将服务器吞吐量提高十倍
servlet 3.0异步 Servlet是Java中处理服务器端逻辑的主要组件,新的3.0规范引入了一些非常有趣的功能,其中异步处理是最重要的功能之一. 可以利用异步处理来开发高度可伸缩的Web应用 ...
- 关于Servlet和异步Servlet
Servlet API是Java EE标准的一部分,自1998年正式发布2.1规范以来,一直是基于Java的企业体系结构的重要组成部分. 它是一种自以为是的API,用于服务围绕一些基本概念构建的请求/ ...
- 如何使用异步Servlet来提高性能
这篇文章将描述一种性能优化技术,适用于与现代Web应用程序相关的常见问题. 如今的应用程序不再只是被动地等待浏览器发起请求,而是希望自己开始通信. 一个典型的示例可能涉及聊天应用程序,拍卖行等–共同点 ...
- Servlet初始化与异步支持
Shared libraries(共享库) / runtimes pluggability(运行时插件能力) 1.Servlet容器启动会扫描,当前应用里面每一个jar包的 ServletContai ...
- JAVA Web Servlet中的异步处理 (2) -- Servlet3.1中的Non-blocking IO支持
JAVA Web Servlet中的异步处理 (2) – Servlet3.1中的Non-blocking IO支持 在servlet 3.1中,新增了non-blocking IO支持. 在serv ...
- JAVA Web Servlet中的异步处理 (1) -- Servlet3.0中的Async支持
JAVA Web Servlet中的异步处理 (1) – Servlet3.0中的Async支持 每个请求来到Web容器,Web容器会为其分配一个线程来专门负责该请求,直到完成处理前,该执行线程都不会 ...
最新文章
- python中的list和array的区别及相互转化
- xfce4的面板只能看见日期没法看见具体时刻
- mybatis学习(41):使用逆向工程
- Spring Boot基础
- 为什么2 *(i * i)比Java中的2 * i * i更快?
- @RequestParam @RequestBody @PathVariable 等参数绑定
- SSM集成activiti6.0错误集锦(二)
- 微型计算机地基本结构,微型计算机地基本结构.ppt
- 机电工程专业技术-测量技术
- python白平衡-树莓派摄像头Camera的使用
- vue 实时搜索 防抖功能
- 值得珍藏的免费观影网站
- 软件著作权的鉴定材料提交
- surface pro 6 黑苹果_surface pro 6 黑苹果
- flutter 弹幕插件_Flutter 实现虎牙/斗鱼 弹幕功能
- 【北邮国院大三上】互联网协议_Internet Protocol_PART A
- Writing an LLVM Pass
- 倒立摆的实现 6.定时器中断和其余初始化
- 微博十年:坐看江湖,搅动风云
- Web前端开发,必须规避的8个错误点!
热门文章
- Chartjs:Line chart的使用及必要参数说明
- driftnet 介绍
- 人们通常先在线性表尾部临时添加一个_视频号——企业争夺的下一个爆款红利...
- Burpsuite—Intruder模块详解
- R语言使用epiDisplay包的lroc函数可视化logistic回归模型的ROC曲线并输出诊断表、输出灵敏度、1-特异度、AUC值等、设置cex.axis参数自定义坐标轴数值刻度值的大小
- 一个优秀的程序员应该具备哪些技能和修养?
- 【职业鸡汤】外国的月亮比较圆 || 专访北美Intel后端设计师Rui
- MongoDB常用命令大全
- 百度无人驾驶、自动驾驶Apollo无人车-战略Xmind思维导图(有哪些大公司有无人驾驶?自动驾驶前沿)
- mysql sprintf_sprintf的用法