Servlet3.0: Introduction Asynccontext

Each request comes to the Web container, and the Web container assigns it a thread that is specifically responsible for the request, and the thread is not freed back to the container until the response is complete. threads consume system resources, and if some requests take a long time to process (such as long-time operations, waiting for a resource), it takes a long time to consume threads, and if such requests are large, many threads are occupied for a longer period of time, which can be a performance burden for the system. It even creates an application's performance bottleneck.  

basically some long processing requests, usually the client does not care about the request to have an immediate response, if possible, let such a request to release the container allocated to the request of the thread, so that the container can have the opportunity to allocate thread resources to other requests, can alleviate the system burden. The request that originally freed the container's allocated thread will be deferred until the processing is completed (for example, the long-time operation is complete and the required resources have been obtained) and the response to the client.

in servlet 3.0, the startasync ( ) method is available on ServletRequest :

Java code

1. Asynccontext Startasync () throws java.lang.IllegalStateException;
3. Asynccontext Startasync (ServletRequest servletrequest,
4. Servletresponse servletresponse)
5. Throws Java.lang.IllegalStateException

Both of these methods will return the real-crop pieces of the Asynccontext interface, which directly uses the original request and response object to build the Asynccontext, which allows you to pass in the request that you set up and respond to the parcel object. after calling the Startasync () method to get the Asynccontext object, the response is deferred and the thread allocated by the container is freed.  

You can asynccontext by getresponse () method Get request, reply object, The response to the client will be deferred to the call Asynccontext complete () method or

to be able to call ServletRequest's Startasync () using Asynccontext, your Servlet must be able to support non-synchronous processing, and if you use @webservlet to label it, you can set its asyncsupported is true. For example:

Java code

1. @WebServlet (urlpatterns = "/some.do", asyncsupported = true)
2. Public class Asyncservlet extends HttpServlet {
3. ...

If you set the servlet using Web. XML, you can set the <async-supported> tag to true :

XML code

2. ...
4. <servlet>
6. <servlet-name>asyncservlet</servlet-name>
8. <servlet-class>cc.openhome.asyncservlet</servlet-class>
10. <async-supported>true</async-supported>
12. </servlet>
14. ...

If the servlet will be unsynchronized, and if there is a filter on its front-end, the filter must also indicate that it supports non-synchronous processing, and if @WebFilter is used, it can also be set to asyncsupported true. For example :

Java code

1. @WebFilter (urlpatterns = "/some.do", asyncsupported = true)
2. Public class Asyncfilter implements filter{
3. ...

If you set a filter using Web. XML, you can set the <async-supported> tag to true:

XML code

2. ...
4. <filter>
6. < filter-name>asyncfilter</ filter-name>
8. < filter-class>cc.openhome.asyncfilter</ filter-class>
10. <async-supported>true</async-supported>
12. </ filter >
14. ...

Below is an example of a non-synchronous processing that, for incoming requests, the servlet obtains its asynccontext and releases the thread allocated by the container, the response is deferred, and a Runnable object is created for these deferred response requests. , and it is queued to a thread pool, the number of threads in the thread pool is fixed, so that those requests that must be processed for a long time are completed in these limited numbers of threads, without having to consume the thread allocated by the container each time the request is made.  

Java code

2. Package cc.openhome;
6. import java.io.*;
8. import java.util.concurrent.*;
10. import javax.servlet.*;
12. import javax.servlet.annotation.*;
14. import javax.servlet.http.*;
18. @WebServlet (name="Asyncservlet", urlpatterns={"/async.do"},
20. asyncsupported = true)
22. public class Asyncservlet extends HttpServlet {
24. //thread pool
26. private Executorservice Executorservice = Executors.newfixedthreadpool (10);
30. protected void ProcessRequest (HttpServletRequest request,
32. HttpServletResponse response)
34. throws Servletexception, IOException {
36. Response.setcontenttype ("text/html;   Charset=utf8 ");
38. Asynccontext CTX = Request.startasync ();
40. Executorservice.submit (new Asyncrequest (CTX));
42. }
46. @Override
48. protected void doget (HttpServletRequest request,
50. HttpServletResponse response)
52. throws Servletexception, IOException {
54. ProcessRequest (request, response);
56. }
60. @Override
62. protected void DoPost (HttpServletRequest request,
64. HttpServletResponse response)
66. throws Servletexception, IOException {
68. ProcessRequest (request, response);
70. }
74. @Override
76. public Void Destroy () {
78. Executorservice.shutdown ();
80. }
82. }

Asyncrequest is a class of practice runnable that simulates a long processing period:

Java code

2. Package cc.openhome;
6. import Java.io.PrintWriter;
8. import Javax.servlet.AsyncContext;
12. public class Asyncrequest implements Runnable {
14. private Asynccontext CTX;
18. Public asyncrequest (Asynccontext ctx) {
20. this.ctx = CTX;
22. }
26. @Override
28. public Void Run () {
30. try {
32. //Analog long-time processing
34. Thread.Sleep (10000);
36. PrintWriter out = Ctx.getresponse (). Getwriter ();
38. Out.println ("Waiting for ...   XD ");
40. //This side only really sends out the response
42. Ctx.complete ();
44. } catch (Exception e) {
46. E.printstacktrace ();
48. }
50. }
52. }

Servlet3.0: Introduction Asynccontext