文档章节

Servlet 3特性:异步Servlet

穿林度水
 穿林度水
发布于 2016/11/07 14:27
字数 1796
阅读 0
收藏 0

本文由 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上面的例子:

  1. 首先Servlet,我们提供异步支持 Annotation @WebServlet  的属性asyncSupported 值为true。
  2. 由于实际实现委托给另一个线程,我们应该有一个线程池实现。我们可以一个通过Executors framework 创建线程池和使用servlet context listener来初始化线程池。
  3. 通过ServletRequest.startAsync方法获取AsyncContext的实例。AsyncContext提供方法让ServletRequest和ServletResponse对象引用。它还提供了使用调度方法将请求转发到另一个 dispatch() 方法。
  4. 编写一个可运行的实现,我们将进行重处理,然后使用AsyncContext对象发送请求到另一个资源或使用ServletResponse编写响应对象。一旦处理完成,我们通过AsyncContext.complete()方法通知容器异步处理完成。
  5. 添加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
转载请保留原文出处、译者和译文链接。]

关于作者: 彭秦进

© 著作权归作者所有

穿林度水
粉丝 0
博文 250
码字总数 167120
作品 0
海淀
程序员
私信 提问
Servlet 3.0 特性详解

Servlet 是 Java EE 规范体系的重要组成部分,也是 Java 开发人员必须具备的基础技能,本文主要介绍了 Servlet 3.0 引入的若干重要新特性,包括异步处理、新增的注解支持、可插性支持等等,为...

那位先生
2015/06/12
0
0
Servlet 3.0 新特性详解

简介: Servlet 是 Java EE 规范体系的重要组成部分,也是 Java 开发人员必须具备的基础技能,Servlet 3.0 是 Servlet 规范的最新版本。本文主要介绍了 Servlet 3.0 引入的若干重要新特性,包...

红薯
2010/04/23
1K
3
Servlet 3.0 新特性

Servlet 3.0 作为 Java EE 6 规范体系中一员,随着 Java EE 6 规范一起发布。该版本在前一版本(Servlet 2.5)的基础上提供了若干新特性用于简化 Web 应用的开发和部署。其中有几项特性的引入...

壹炮倾城
2013/06/13
0
1
Servlet3.0新特性剖析

Servlet3.0规范的新特性主要是为了3个目的: 1.简化开发 2.便于布署 3.支持Web2.0原则 为了简化开发流程,Servlet3.0引入了注解(annotation),这使得web布署描述符web.xml不在是必须的选择...

长平狐
2012/09/03
195
0
厉害了,Servlet3的异步处理机制

Servlet3发布好几年了,又有多少人知道它的新特性呢?下面简单介绍下。 主要增加了以下特性: 1、异步处理支持 2、可插性支持 3、注解支持,零配置,可不用配置web.xml ... 异步处理是什么鬼...

java技术栈
2017/08/13
0
0

没有更多内容

加载失败,请刷新页面

加载更多

vmstat命令详解

https://www.cnblogs.com/ggjucheng/archive/2012/01/05/2312625.html

流光韶逝
16分钟前
0
0
如何理解算法时间复杂度的表示

先从O(1) 来说,理论上哈希表就是O(1)。因为哈希表是通过哈希函数来映射的,所以拿到一个关键 字,用哈希函数转换一下,就可以直接从表中取出对应的值。和现存数据有多少毫无关系,故而每次执...

yky20190625
32分钟前
2
0
分布式架构 实现分布式锁的常见方式

一、我们为什么需要分布式锁? 在单机时代,虽然不需要分布式锁,但也面临过类似的问题,只不过在单机的情况下,如果有多个线程要同时访问某个共享资源的时候,我们可以采用线程间加锁的机制...

太猪-YJ
今天
7
0
GitLab Docker 安装记录

安装环境 环境Centos7.4 64 1.拉取镜像文件 docker pull gitlab/gitlab-ce:latest 2.docker 安装 git.zddts.com 为访问域名或换成可以访问的IP docker run -d --hostname git.***.com -p ......

侠者圣
今天
0
0
EfficientNet: 再论 CNN 的网络规模

由于这里公式无法正常显示,所有内容以图片内容上传,如有需要,可提供 pdf 版。

爱吃草莓的皮卡丘
今天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部