tomcat7特性 serlvet async特性

标签: tomcat7 serlvet async | 发表时间:2017-10-12 03:13 | 作者:xiaoxiaoHer
分享到:
出处:http://www.iteye.com

 

每个请求来到Web容器,Web容器会为其分配一个线程来专门负责该请求,直到完成处理前,该执行线程都不会被释放回容器。 执行线程会耗用系统资源,若有些请求需要长时间处理(例如长时间运算、等待某个资源),就会长时间占用执行线程。 
若这类的请求很多,许多执行线程都被长时间占用,而在web容器内,可以使用的线程都是有限的,这对于系统就会是个负担,甚至造成应用程式的性能瓶颈。

基本上一些需长时间处理的请求,通常客户端也较不在乎请求后要有立即的回应。若可以,让这类请求先释放容器分配给该请求的执行线程,让容器可以有机会将执行线程资源分配给其它的请求,可以减轻系统负担。

很多项目在遇到需长时间处理的任务时,经常启一个新线程或者扔到线程池中,这样不耽误任务主线的流程,这个servlet的asynch特性其实发挥同样的作用

释放了容器所分配执行线程的请求,其回应将被延后,直到处理完成(例如长时间运算完成、所需资源已获得)再行对客户端的回应, 如果超过浏览器的链接时长,会将servlet中的内容返回,而asyncContext中的内容则不能返回,服务器抛出java.lang.IllegalStateException错误

在Servlet 3.0中,提供了AsyncContext,对异步执行的上下文提供支持。在ServletRequest上提供了 startAsync( )方法,用于启动异步工作线程。而且AsynchContext还提供了Timeout等设置。

你可以透过AsyncContext的getRequest() 、 getResponse()方法取得Request、Response对象,此次对客户端的响应将暂缓至调用AsyncContext的complete()方法或dispatch()为止,前者表示回应完成,后者表示将响应调派给指定的URL 。

若要能调用ServletRequest的startAsync()使用AsyncContext,则此Servlet 必须能支援非同步处理,如果使用@WebServlet来标注,则可以设定其asyncSupported为true 。 例如:

   @WebServlet(urlPatterns = "/some.do", asyncSupported = true )   
public class AsyncServlet extends HttpServlet 
...   
  • 1
  • 2
  • 3

如果使用web.xml设定Servlet,则可以设定标签为true :

   ...   
<servlet>   
<servlet-name>AsyncServlet</servlet-name>   
<servlet-class>com.pkgname.AsyncServlet</servlet-class>   
<async-supported>true</async-supported>   
</servlet>   
...   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

如果Servlet将会异步处理,若其前端有过滤器,则过滤器亦需标示其支援异步处理,如果使用@WebFilter ,同样是可以设定其asyncSupported为true 。 例如:

   @WebFilter(urlPatterns = "/some.do", asyncSupported = true )   
public class AsyncFilter implements Filter{   
...   
  • 1
  • 2
  • 3

如果使用web.xml设定过滤器,则可以设定标签为true :

   ...   
<filter>   
< filter -name>AsyncFilter</ filter -name>   
< filter -class>com.pkgname.AsyncFilter</ filter -class>   
<async-supported>true</async-supported>   
</ filter >   
...   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

注意: 
使用异步处理方式,web容器的请求处理线程释放了,可以服务其他的请求处理。但是该Request的处理并没有结束,在使用AsyncContext的complete或者dispatch完成后,这个request的处理才结束。

   简单的示例:
  • 1
  • 2
   package com.ss;

import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

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;

//  import com.cndatacom.thread.BusinessHandleThread;

/**
 * 异步处理Servlet
 * @author 
 */

/**
 * asyncSupported属性默认是false,如果需要开启支持异步处理功能,需要设置为true
 */
@WebServlet(name = "AsyncServlet", urlPatterns = "/AsyncServlet2", asyncSupported = true)
public class AsyncServlet2 extends HttpServlet {
    /**
     * 
     */
    private static final long serialVersionUID = -2749650094193187229L;

    @Override
    protected void doGet(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();

        Date date = new Date(System.currentTimeMillis());
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss Z");

        out.println("Servlet  begin --" + sdf.format(date) + "<br>");// 响应输出到客户端

        // 进入异步模式,调用业务处理线程进行业务处理
        // Servlet不会被阻塞,而是直接往下执行
        // 业务处理完成后的回应由AsyncContext管理
        AsyncContext asyncContext = request.startAsync();
        BusinessWorkerThread businessHandleThread = new BusinessWorkerThread(
                asyncContext);
        Thread thread = new Thread(businessHandleThread);
        thread.start();
        //asyncContext.start(businessHandleThread);//也可以用这种方法启动异步线程

        date = new Date(System.currentTimeMillis());
        out.println("Servlet end --" + sdf.format(date) + "<br>");
        out.flush();

    }
}
  • 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
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
   ------
  • 1
  • 2
   package com.ss;

import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.AsyncContext;
import javax.servlet.ServletResponse;

/**
 * 业务处理线程
 * 
 * @author 
 */
public class BusinessWorkerThread implements Runnable {

    // 异步操作的上下文对象,通过构造方法传进来
    private AsyncContext asyncContext;

    public BusinessWorkerThread(AsyncContext asyncContext) {
        this.asyncContext = asyncContext;
    }

    @Override
    public void run() {
        try {
            // do some work...
            Thread.sleep(8000); // 和browser的timeout时间相关。如果browser上timeout是30s,则大于30时,网络已经断开。这是就会异常。

            ServletResponse response = asyncContext.getResponse();
            PrintWriter out = response.getWriter();
            Date date = new Date(System.currentTimeMillis());
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss Z");

            out.println("business worker finished --"+ sdf.format(date));// 响应输出到客户端

            // 告诉启动异步处理的Servlet异步处理已完成,Servlet就会提交请求响应
            asyncContext.complete();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
  • 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
   输出: 在浏览器中,输出的内容按照后面的时间显示在页面上。
  • 1
  • 2
   Servlet begin --22:33:57 +0800
Servlet end --22:33:57 +0800
business worker finished --22:34:05 +0800
  • 1
  • 2
  • 3

注意: 使用浏览器访问,因为各个浏览器的http请求超时设置不同,比如我的chrome是30秒。AsyncContext中对应的工作线程的持续时间需要小于浏览器的http超时时间。

AsyncListener

AsyncContext还可以设置一个Listener,对4个事件进行处理:

示例:

    package com.ss;

import java.io.IOException;

import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class AsyncServletTest
 */
@WebServlet(asyncSupported = true, urlPatterns = { "/AsyncTest" })
public class AsyncServletTest extends HttpServlet {

    String param = "";

    private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     */
    public AsyncServletTest() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
     *      response)
     */

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

        // 1 start async
        final AsyncContext ctx = req.startAsync();
        param = ctx.getRequest().getParameter("seq");
        System.out.println("getRequest request seq: " + param);

        // 2 set the timeout
        ctx.setTimeout(0);

        // 3 add listener
        ctx.addListener(new AsyncListener() {

            @Override
            public void onTimeout(AsyncEvent arg0) throws IOException {
                System.out.println("onTimeout...");
            }

            @Override
            public void onStartAsync(AsyncEvent arg0) throws IOException {
                System.out.println("onStartAsync...");
            }

            @Override
            public void onError(AsyncEvent arg0) throws IOException {
                System.out.println("onError...");
            }

            @Override
            public void onComplete(AsyncEvent arg0) throws IOException {
                System.out.println("onComplete...");
            }
        });

        // 4 run a thread
        ctx.start(new Runnable() {
            @Override
            public void run() {
                String seq = ctx.getRequest().getParameter("seq");

                System.out.println(">>>>>now respone: " + seq);

                int n = 0;
                try {
                    // hold until receive exit
                    while (!param.equals("exit")) {

                        n++;
                        if (n % 100000000 == 0) {

                            System.out.println(seq + ": ..." + n);
//                          
                        }
                    }
                    ctx.getResponse().getWriter().write(seq+" -- "+n);

                } catch (IOException e) {
                    e.printStackTrace();
                }

                ctx.complete();
            }

        });
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
     *      response)
     */
    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        System.out.println("doPost...");
    }

}


已有 0 人发表留言,猛击->> 这里<<-参与讨论


ITeye推荐



相关 [tomcat7 serlvet async] 推荐:

tomcat7特性 serlvet async特性

- - 编程语言 - ITeye博客
每个请求来到Web容器,Web容器会为其分配一个线程来专门负责该请求,直到完成处理前,该执行线程都不会被释放回容器. 执行线程会耗用系统资源,若有些请求需要长时间处理(例如长时间运算、等待某个资源),就会长时间占用执行线程. 若这类的请求很多,许多执行线程都被长时间占用,而在web容器内,可以使用的线程都是有限的,这对于系统就会是个负担,甚至造成应用程式的性能瓶颈.

tomcat7之websocket

- - ITeye博客
从tomcat7.0.26之后开始支持websocket,建议大家使用tomcat7.0.30,期间版本的接口有一些改动. chrome默认支持websocket. 其他浏览器可能由于安全原因,默认是关闭的. // 与7.0.27不同的,Tomcat改变了createWebSocketInbound方法的定义,增加了一个HttpServletRequest参数.

script的defer和async

- - 携程UED
我们常用的script标签,有两个和性能、js文件下载执行相关的属性:defer和async. defer的含义【摘自 https://developer.mozilla.org/En/HTML/Element/Script】. This Boolean attribute is set to indicate to a browser that the script is meant to be executed after the document has been parsed..

async vs defer 属性

- - 进步博客
<script>元素的async和defer属性支持度已经不错了,是时候详细了解它们了. <script>脚本不设置任何属性. HTML文档解析过程中,遇到script文档时,会停止解析HTML文档,发送请求获取script文档(如果是外部文档的话). 脚本执行后,才恢复HTMl文档解析.

Tomcat7配置双向SSL

- - CSDN博客推荐文章
//ca-cert.pem即为CA根证书,可将其下发到客户端,导入作为根证书.  如果按请求生成CA证书,由证书申请者生成请求文件certreq.txt. CA端执行签名,生成证书文件1.cer. 4.将证书导出成浏览器支持的.p12格式,密码changeit. 4.将证书导出成浏览器支持的.p12格式 :.

(原)CentOS_linux5.5、JDK1.6、tomcat7、nginx、mysql5.1、mongodb安…

- - Linux - 操作系统 - ITeye博客
转: http://blog.sina.com.cn/s/blog_438308750100xsb5.html. # 关闭不需要的服务按上面的安装关闭 ip6tables、jexec、kudzu、lvm2-monitor、mcstrans、netfs、rawdevices、restorecond. 2.禁止Ctrl+Alt+Delete重新启动机器命令.

Async Http Client 欺骗漏洞 (CVE-2013-7397)

- - 开源中国社区最新新闻
发布日期:2015-06-25. 更新日期:2015-06-25. Async Http Client是异步HTTP及WebSocket客户端Java库. Async Http Client 1.9.0之前版本,会跳过了X.509证书验证,除非keyStore位置及trustStore位置均显式设置.

在 Percona XtraDB Cluster 裡使用 async replication 時人工 failover 的方式…

- - Gea-Suan Lin's BLOG
在使用 Galera Cluster 時還是可以架設一般的 slave server ( Percona XtraDB Cluster 則是 Percona 對 Galera Cluster 的封裝),像是這樣的架構:. 其中 node{1,2} 為 cluster,node3 則是傳統的 async replication,來源的 master 為 node1.

使用async属性异步加载执行JavaScript

- - WebHek
HTML5让我兴奋的一个最大的原因是,它里面实现的新功能和新特征都是我们长久以来一直期待的. 比如,我以前一直在使用 placeholders,但以前必须要用JavaScript实现. 而HTML5里给JavaScript标记提供的 async属性,使JavaScript能异步加载执行. 之前我需要各种的JavaScript插件来实现这种功能,但现在这个新属性能让我们轻松的实现异步加载.

Tomcat7调优及JVM性能优化for Linux环境

- - 互联网 - ITeye博客
该优化针对Linux X86_X64环境. Tomcat优化其实就是对server.xml优化(开户线程池,调整http connector参数). 搜索【<Executor name="tomcatThreadPool"】,开启并调整为. 搜索【port="8080"】,调整为.