"Go" multi-user access Servlet,servlet single-instance multithreading

1. Public class MyClass {
2. private String variable1;
3. private static String variable2;
4. Public MyClass () {
5. }
6. public Void Method () {
7. String Variable3;
8. }
9. }

The above is a class that is handy to write, does not have any meaning, just to emphasize some concepts, this is related to this topic:
1) Classification of variables in Java:
A. Instance variables
B. Local variables
C. Static variables
This is not a basic Java tutorial, so it is not exhaustive to each of the basic points of knowledge (the following is a distinction between objects and object variables, <<core java2>> is strictly differentiated, but most textbooks are not too harsh to distinguish them)
A. Instance variables: belong to each object, that is, each object has a copy of this variable. The variable1 on the above point to the instance variable.
B. Local variables: Work in a scope, leaving the scope behind to become garbage. The above variable3 points to local variables, and local variables exist in the method.
C. Static variable: belongs to a class, that is, all objects have a copy. The variable2 above points to a static variable.

2) instantiation of the servlet container:
How the servlet is instantiated, not what we care about, is how many times the servlet is instantiated, whether each request is instantiated or just instantiated once? It's too easy to answer this question:

[Java]View Plaincopy

2. Public class Test extends HttpServlet {
4. private static int count = 0;
6. private int num = 0;
10. Public Test () {
12. super ();
14. Count + +;
16. System.out.println ("instanced" +count+"Times");
18. }
22. public void doget (HttpServletRequest request, httpservletresponse response)
24. throws Servletexception, IOException {
26. Response.setcontenttype ("text/html");
28. num + +;
30. System.out.println ("was visited" + num+"Times");
32. }
34. }

Open the browser, access the specified servlet, and keep refreshing, as a result:
Instantiated 1 of Times
has been visited 1 times
has been visited 2 times
has been visited 3 times

Do not close the browser, and then open a browser access, continuous point refresh, the result is:
has been visited 4 times
has been visited 5 times
has been visited 6 times
has been visited 7 times
has been visited 8 times

Visible to more than just the same user, only one object is instantiated for other users.
In other words, Tomcat only instantiates a servlet, producing an object.

How does the servlet container access the corresponding multi-user concurrently? Answer: Multithreading. Run the Doget or Dopost method with a separate thread for each access. That is, the internal implementation of the servlet container might be:

[Java]View Plaincopy

1. class .  extends thread{  
2.     public  void run () {  
3.         if (request  for  get)   
4.             servlet.doget ();    // servlet point to the instance of the Servlet class you requested   
5.        else  if (request  to  post)   
6.            servlet.dopost ();   
7. &NBSP;&NBSP;&NBSP;&NBSP;}&NBSP;&NBSP;
8. }  

This is fine, but some novice programmers may put this error:

[Java]View Plaincopy

2. Public class Test extends HttpServlet {
4. private PrintWriter out;
8. Public Test () {
10. super ();
12. }
16. public void doget (HttpServletRequest request, httpservletresponse response)
18. throws Servletexception, IOException {
20. Response.setcontenttype ("text/html");
22. out = Response.getwriter ();
24. Out.println (Request.getremoteaddr ());
26. }
28. }

What's the result? Single A accesses the test, obtains an instance by Response.getwriter (), and saves it in the out, assuming B executes the response.getwriter () before a, and starts executing out.println ( REQUEST.GETREMOTEADDR ()), when out saves the PrintWriter object that is not obtained by B itself through the getwriter () method, but the result of a run getwriter, then B outputs the address of a. Take a look at the following example:

Create a webapp, called the web, to build the sendname.html HTML file, with the following content:

[Java]View Plaincopy

3. <body>
4. <form action="/web/test" >
5. <input type="text" name="name"/>
6. <input type="Submit"/>
7. </form>
8. </body>

Create a servlet called Test that reads as follows:

[Java]View Plaincopy

2. Public class Test extends HttpServlet {
4. private String name;
6. public void doget (HttpServletRequest request, httpservletresponse response)
8. throws Servletexception, IOException {
10. Response.setcontenttype ("text/html");
12. PrintWriter out = Response.getwriter ();
14. Name = Request.getparameter ("name");
16. Out.println ("I input" +name);
18. try{thread.sleep (5000);} catch (Exception ex) {}
20. Out.println ("I AM" +name);
22. Out.flush ();
24. Out.close ();
26. }
28. }

Open 2 sendname.html (http://localhost:8080/web/sendname.html) through the browser and enter names A and B (not more than 5 seconds apart):
The results of the 2 pages shown are:

I input b I am b

I input A I am B

This is the multithreading problem in the servlet. The solution is simple, not to use instance variables, at least not when absolutely necessary.
This problem is more pronounced in JSPs, as the use of <%! The variable declaration made by%> is an instance variable, and if it is to be defined, then use synchronized to add synchronized before the method using the instance variable, which is also deprecated, here is an example:

[Java]View Plaincopy

2. <%@ page contenttype="text/html;charset=gb2312"%>
4. <HTML>
6. <BODY>
10. <!--number is a critical area--
12. <%!      int number=0;
14. synchronized void Countpeople ()
16. {number++;
18. }
20. %>
22. <% countpeople ();
24. %>
26. <P><P> you are the first
28. <%=number%>
30. Visitors to our site.
32. </BODY>
34. </HTML>

In <%! The way defined in%> is also called by multithreading.
For JSP pages, in addition to using synchronized, you can use the IsThreadSafe of the page directive element to control whether the entire page can be accessed in multiple threads.

"Go" multi-user access Servlet,servlet single-instance multithreading