Analysis on the action thread safety of STRUTS1 and STRUTS2

Brief analysis on the action thread safety problem of Struts1 and Struts2 http://blog.csdn.net/virgoboy2004/article/details/5876133

"Description of the problem" recently, the company arranged for me to interview Java freshman, the interviewer is generally working for more than 1 years of new people (Here I install old, in fact, I have only worked for 3 years), when asked about Struts1 and Struts2 action of the thread safety issues, Most of it is to be in a shuffle, can't answer why. So here I sort out my personal understanding.

"Answer to the question"

This is due to the working principle of the servlet. Let's start by briefly reviewing the life cycle of the servlet "initializing->init->service->destroy-> Offload".

As we all know here, when we define a servlet in Web. XML, we can give them a value of "Load-on-startup" if the servlet's Load-on-startup configuration item is greater than 0, then in the Context The container is instantiated when it is started, and tomcat loads and instantiates an object for each servlet (note: That is, every servlet that our user configures in Web. XML is instantiated as a Servlet object)

A, the following configuration indicates that two Servlet objects will be instantiated, even if they correspond to the same servlet class

[HTML]View Plaincopy

2. <? XML version= "1.0" encoding="UTF-8"?>
4. <Web-app version="2.5"
6. xmlns="Http://java.sun.com/xml/ns/javaee"
8. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
10. xsi:schemalocation= "Http://java.sun.com/xml/ns/javaee
12. Http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd ">
14. <servlet>
16. <servlet-name>servlettest1</servlet-name>
18. <servlet-class>web.servlet.servlettest1</servlet-class>
20. </servlet>
24. <servlet-mapping>
26. <servlet-name>servlettest1</servlet-name>
28. <url-pattern>/servlet/servlettest1</url-pattern>
30. </servlet-mapping>
34. <servlet>
36. <servlet-name>servlettest2</servlet-name>
38. <servlet-class>web.servlet.servlettest1</servlet-class>
40. </servlet>
44. <servlet-mapping>
46. <servlet-name>servlettest2</servlet-name>
48. <url-pattern>/servlet/servlettest1</url-pattern>
50. </servlet-mapping>
52. </Web-app>

b, the following configuration indicates that only one servlet will be instantiated

[HTML]View Plaincopy

2. <? XML version= "1.0" encoding="UTF-8"?>
4. <Web-app version="2.5"
6. xmlns="Http://java.sun.com/xml/ns/javaee"
8. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
10. xsi:schemalocation= "Http://java.sun.com/xml/ns/javaee
12. Http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd ">
14. <servlet>
16. <servlet-name>servlettest1</servlet-name>
18. <servlet-class>web.servlet.servlettest1</servlet-class>
20. </servlet>
24. <servlet-mapping>
26. <servlet-name>servlettest1</servlet-name>
28. <url-pattern>/servlet/servlettest1</url-pattern>
30. </servlet-mapping>
34. <servlet-mapping>
36. <servlet-name>servlettest1</servlet-name>
38. <url-pattern>/servlet/servlettest1</url-pattern>
40. </servlet-mapping>
42. </Web-app>

In other words, the Tomcat container implements a singleton schema for the servlet, and for a servlet class, there is always only one servlet object.

Let's explain why STRUTS1 is not thread-safe.

1, Struts1

Struts1 is a direct implementation of the Java Web servlet interface, so it inherits the Tomcat implementation of the servlet, and each action in the struts1 corresponds to a servlet class, So the action here is a singleton after being instantiated by Tomcat, so Struts1 has a multithreaded problem.

For example:

You define an int i = 0 in action;

This I is then manipulated in one of the methods inside the action.

This is done in the following code:

[Java]View Plaincopy

2. Package web.servlet;
6. Import java.io.IOException;
8. Import Java.io.PrintWriter;
12. Import javax.servlet.ServletException;
14. Import Javax.servlet.http.HttpServlet;
16. Import Javax.servlet.http.HttpServletRequest;
18. Import Javax.servlet.http.HttpServletResponse;
22. /**
24. * @author Jack Zhang
26. * @version vb1.0
28. * @Email [Email protected]
30. * @Date 2013-4-21
32. */
34. Public class ServletTest1 extends HttpServlet
36. {
40. public int i = 0;
42. /** 
44. * Constructor of the object.
46. */
48. Public ServletTest1 ()
50. {
52. super ();
54. }
58. /** 
60. * The Doget method of the servlet. <br>
62. *
64. * This method was called when a form had its tag value method equals to get.
66. *
68. * @param request the request send by the client to the server
70. * @param response The response send by the server to the client
72. * @throws servletexception If an error occurred
74. * @throws IOException If an error occurred
76. */
78. public void doget (HttpServletRequest request, httpservletresponse response)
80. throws Servletexception,
82. IOException
84. {
86. i++;
90. Response.setcontenttype ("text/html");
92. PrintWriter out = Response.getwriter ();
94. Out
96. . println ("<!  DOCTYPE HTML public \ "-//W3C//DTD HTML 4.01 transitional//en\" > ");
98. Out.println ("<HTML>");
100. Out.println ("
102. Out.println ("<BODY>");
104. Out.print ("i=" +i);
106. Out.println ("</BODY>");
108. Out.println ("</HTML>");
110. Out.flush ();
112. Out.close ();
114. }
116. }

When accessing this servlet, how many times do you visit, and what is the value of I?

So: We can't define attributes in action when we're using STRUTS1. To use only words can only be defined in the method.

That's why it's not a multi-threading problem to put the definition of a property into a method, and I'm sure you'll find the answer to the question about how the Java memory model allocates memory to the method in JMM.

2, Struts2

Above we understand the Struts1 inside the multithreading problem, that Struts2 how to solve this problem? In fact, the reason is very simple, because STRTUS2 will get the user's HTTP request, and then responsible for each request to instantiate an action object, but it is noted that the action object here and Struts1 inside the action object is not a concept at all, The action class inside the STRUTS1 is a servlet class, and the action class here is just a normal Java class. This is why the action inside the STRUTS1 is thread insecure, and the action inside the STRUTS2 is a thread-safe cause.

So we look back and see how struts2 is different from the struts1 of the servlet. Readers who have read the previous analysis must know that Struts1 's action does not have any wrapper on the servlet, it is a servlet interface within the Java WEB API that is implemented directly. That's why thread safety is a problem, but the struts2 bottom helps us encapsulate the servlet so developers don't have to touch the servlet directly. The specific approach is:

Strtus2 intercepts the servlet request and then instantiates an action object for each request, destroying the action object after the request has ended. As to Strtus2 specific how to do, I do not want to be redundant, we can see the Struts2 of the relevant introduction.

In Struts2 because there is no difference between the action and the normal Java class (that is, you do not have to implement a struts interface like the one in Struts1, interested friends can see for themselves), so we can use spring to manage the action of the Struts2. , this time we have to pay attention, because when we are in spring to define the bean, spring by default is a singleton mode. So at this point, you need to modify the spring configuration file---that is, modify scope to prototype.

Analysis on the action thread safety of STRUTS1 and STRUTS2