Servlet3中的AsyncContext异步和多线程异步有什么区别

0 0

Servlet3中的AsyncContext异步和多线程异步有什么区别5

我如果想异步向页面输出，则可以使用Servlet3中的AsyncContext。也可以在Servlet中另外启动一个多线程处理，让主线程先返回页面

两种方式的代码如下

public class ListServlet extends HttpServlet 
{
    private static final long serialVersionUID = 1L;
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException 
    {
        response.getWriter().println("I am begin output !");
        response.getWriter().flush();
         
        //方式一
        AsyncContext async = request.startAsync();
        new AsyncOutput(async).start();
         
        //方式二
        new ThreadOutput(response).start();
         
        response.getWriter().println("I am finash output !");
        response.getWriter().flush();
    }
 
}
 
class AsyncOutput extends Thread
{
    private AsyncContext async;
    public AsyncOutput(AsyncContext async)
    {
        this.async = async;
    }
    public void run() 
    {
        try
        {
            Thread.sleep(3000);
            async.getResponse().getWriter().println("I was three minutes late !");
            async.getResponse().getWriter().flush();
        }catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}
 
class ThreadOutput extends Thread
{
    private HttpServletResponse response;
    public ThreadOutput(HttpServletResponse response)
    {
        this.response = response;
    }
    public void run() 
    {
        try
        {
            Thread.sleep(3000);
            response.getWriter().println("I was three minutes late !");
            response.getWriter().flush();
        }catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

这两种效果是一样啊

既然如此，那还搞什么AsyncContext

AsyncContext有什么不一样的地方

以上两种使用方式，有什么区别？

求指点

servlet3 AsyncContext

2014年5月12日 16:14

java_web_hack1
4
0 0 6

3个答案按时间排序按投票排序

0 0

采纳的答案

AsyncContext不是让你异步输出，而是让你同步输出，但是解放服务器端的线程使用，使用AsyncContext的时候，对于浏览器来说，他们是同步在等待输出的，但是对于服务器端来说，处理此请求的线程并没有卡在那里等待，则是把当前的处理转为线程池处理了，关键就在于线程池，服务器端会起一个线程池去服务那些需要异步处理的请求，而如果你自己每次请求去起一个线程处理的话，这就有可能会耗大量的线程。

你目前对AsyncContext 的使用并不是最佳实践，实际上应该这样使用：

final AsyncContext asyncContext = request.getAsyncContext();
            asyncContext.addListener(new AsyncListener() {
                @Override
                public void onComplete(AsyncEvent event) throws IOException {
                    //在这里处理正常结束的逻辑
                }

                @Override
                public void onTimeout(AsyncEvent event) throws IOException {
                    //在这里处理超时的逻辑
                }

                @Override
                public void onError(AsyncEvent event) throws IOException {
                    //在这里处理出错的逻辑
                }

                @Override
                public void onStartAsync(AsyncEvent event) throws IOException {
                    //在这里处理开始异步线程的逻辑
                }
            });
            //设置超时的时间，到了时间以后，会回调onTimeout的方法
            asyncContext.setTimeout(10000L);
            //在这里启动，传入一个Runnable对象，服务器会把此Runnable对象放在线程池里面执行
            asyncContext.start(new Runnable() {
                @Override
                public void run() {
                    //在这里做耗时的操作，如果做完，则调用complete方法通知回调，异步处理结束了
                    asyncContext.complete();
                }
            });

2014年5月12日 18:10

lbfhappy
281
0 0 15

添加评论

0 0

我们可以在容器内部配置一些异步超时时间关于AsyncContext的配置，以超时为例，当异步线程中的数据在向response中写的时候，如果已经超时，此时的数据就写不回去了。而通过线程持有response的方式，其实就相当于组合使用了response一样，异步Context的一切其它配置，都不会影响之。我想这应该是两者的区别吧。

2014年5月12日 18:17

chainhou
192
0 0 15

添加评论

0 0

上面的排版太难看了，看这个：

final AsyncContext asyncContext = request.getAsyncContext();
//添加监听器监听异步的执行结果
asyncContext.addListener(new AsyncListener() {
    @Override
    public void onComplete(AsyncEvent event) throws IOException {
        //在这里处理正常结束的逻辑
    }

    @Override
    public void onTimeout(AsyncEvent event) throws IOException {
        //在这里处理超时的逻辑
    }

    @Override
    public void onError(AsyncEvent event) throws IOException {
        //在这里处理出错的逻辑
    }

    @Override
    public void onStartAsync(AsyncEvent event) throws IOException {
        //在这里处理开始异步线程的逻辑
    }
});
//设置超时的时间，到了时间以后，会回调onTimeout的方法
asyncContext.setTimeout(10000L);
//在这里启动，传入一个Runnable对象，服务器会把此Runnable对象放在线程池里面执行
asyncContext.start(new Runnable() {
    @Override
    public void run() {
        //在这里做耗时的操作，如果做完，则调用complete方法通知回调，异步处理结束了
        asyncContext.complete();
    }
});

2014年5月12日 18:11

lbfhappy
281
0 0 15

添加评论

已解决问题

未解决问题

排行榜

查看全部排名>>