Servlet的线程安全问题

 

Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。

　　当客户端第一次请求某个Servlet时，Servlet容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时，一般不会再实例化该Servlet类，也就是有多个线程在使用这个实例。

　　这样的话，当两个或多个线程同时访问同一个Servlet时，可能会发生多个线程同时访问同一资源的情况，数据可能会变得不一致，所以就很容易造成一系列的一些安全性问题。

　　解决此类的方法也有多

　　1、实现 SingleThreadModel 接口

　　该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定，那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。这种方法只要继承这个接口就行了

　　public class XXXXX extends HttpServlet implements SingleThreadModel { ………… }

　　2、同步对共享数据的操作

　　使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段，在本论文中可以通过同步块操作来保证Servlet的线程安全。同步后的代码如下：

　　Public class XXXXXX extends HttpServlet { ………… synchronized (this){XXXX} }

　　3、避免使用实例变量

　　线程安全问题还有些是由实例变量造成的，只要在Servlet里面的任何方法里面都不使用实例变量，那么该Servlet就是线程安全的。

　　对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。但是，如果一个Servlet实现了SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。SingleThreadModel在Servlet2.4中已不再提倡使用;同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大下降。这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。另外为保证主存内容和线程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。所以在实际的开发中也应避免或最小化Servlet 中的同步代码;在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。

　　小结

　　Servlet的线程安全问题只有在大量的并发访问时才会显现出来，并且很难发现，因此在编写Servlet程序时要特别注意。线程安全问题主要是由实例变量造成的，因此在Servlet中应避免使用实例变量。如果应用程序设计无法避免使用实例变量，那么使用同步来保护要使用的实例变量，但为保证系统的最佳性能，应该同步可用性最小的代码路径。

 

 

 

 

 

 

 

 

关于Servlet线程安全

简单的说, servlet绝对不是线程安全的, 所以, 尽量比声明servlet的属性, 虽然可以得到解决办法, 但是性能上都不好的.

 

Servlet生命周期

　　装载Servlet。这项操作一般是动态执行的。然而，Server通常会提供一个管理的选项，用于在Server启动时强制装载和初始化特定的Servlet。

　　Server创建一个Servlet的实例

　　Server调用Servlet的init()方法

　　一个客户端的请求到达Server

　　Server创建一个请求对象

　　Server创建一个响应对象

　　Server激活Servlet的service()方法，传递请求和响应对象作为参数

　　service()方法获得关于请求对象的信息，处理请求，访问其他资源，获得需要的信息

　　service()方法使用响应对象的方法，将响应传回Server，最终到达客户端。service()方法可能激活其它方法以处理请求，如doGet()或doPost()或程序员自己开发的新的方法

　　对于更多的客户端请求，Server创建新的请求和响应对象，仍然激活此Servlet的 service()方法，将这两个对象作为参数传递给它。如此重复以上的循环，但无需再次调用init()方法。一般Servlet只初始化一次 ,当Server不再需要Servlet时(一般当Server关闭时)，Server调用Servlet的Destroy()方法。

Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。当客户端第一次请求某个Servlet时， Servlet容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时，一般不会再实例化该 Servlet类，也就是有多个线程在使用这个实例。 这样，当两个或多个线程同时访问同一个Servlet时，可能会发生多个线程同时访问同一资源的情况，数据可能会变得不一致。所以在用Servlet构建的Web应用时如果不注意线程安全的问题，会使所写的Servlet程序有难以发现的错误。

实例变量不正确的使用是造成Servlet线程不安全的主要原因。下面针对该问题给出了三种解决方案并对方案的选取给出了一些参考性的建议。

 

　　1、实现 SingleThreadModel 接口

 

　 　该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不 会有两个线程被同时执行，当然也就不存在线程安全的问题。这种方法只要将前面的Concurrent Test类的类头定义更改为：

 

Public class Concurrent Test extends HttpServlet implements SingleThreadModel {

     …………

} 

　　2、同步对共享数据的操作

 

　　使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段，在本论文中的Servlet可以通过同步块操作来保证线程的安全。同步后的代码如下： 

 

…………

Public class Concurrent Test extends HttpServlet { …………

Username = request.getParameter ("username"); 

Synchronized (this){

Output = response.getWriter (); 

Try {

Thread. Sleep (5000);

} Catch (Interrupted Exception e){}

output.println("用户名:"+Username+"

"); 

} 

}

}

　　3、避免使用实例变量

 

　　本实例中的线程安全问题是由实例变量造成的，只要在Servlet里面的任何方法里面都不使用实例变量，那么该Servlet就是线程安全的。

 

　　修正上面的Servlet代码，将实例变量改为局部变量实现同样的功能，代码如下：

 

…… 

Public class Concurrent Test extends HttpServlet {public void service (HttpServletRequest request, HttpServletResponse 

Response) throws ServletException, IOException {

Print Writer output; 

String username;

Response.setContentType ("text/html; charset=gb2312");

…… 

} 

}

　 　对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。但是，如果一个Servlet实现了 SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。 SingleThreadModel在Servlet2.4中已不再提倡使用；同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大 下降。这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。另外为保证主存内容和线 程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。所以在实际的开发中也应避免或最小化 Servlet 中的同步代码；在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。

 

 

 

 

 

 

Java的内存模型JMM（Java Memory Model）JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有实例变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory)，工作内存由缓存和堆栈两部分组成，缓存中保存的是主存中变量的拷贝，缓存可能并不总和主存同步，也就是缓存中变量的修改可能没有立刻写到主存中；堆栈中保存的是线程的局部变量，线程之间无法相互直接访问堆栈中的变量。根据JMM，我们可以将论文中所讨论的Servlet实例的内存模型抽象为图3所示的模型。

对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。但是，如果一个Servlet实现了SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。SingleThreadModel在Servlet2.4中已不再提倡使用；同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大下降。这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。另外为保证主存内容和线程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。所以在实际的开发中也应避免或最小化 Servlet 中的同步代码；在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。

 

 

 

 

 

 

 

 

1.  变量的线性安全：这里的变量指字段和共享数据（如表单参数值）。

将参数变量本地化。多线程并不共享局部变量，所以要尽可能地在servlet中使用局部变量。例如：String user=request.getParameter("user");

使用同步块Synchronized，防止可能异步调用的代码块，这就意味着线程需要排队处理。但要注意在使用同步块的范围要尽可能的小，不要直接在sevice方法和响应方法上使用，这样会严重影响性能。

2.  属性的线性安全：ServletContext,HttpSession,ServletRequest对象中的属性。

ServletContext（线程不安全）：ServletContext可以同时进行多线程读/写属性，线程是不安全的。要对属性的读写进行同步处理或进行深度Clone()。所以在Servlet上下文中要尽量少保存会被修改（写）的数据，可以使用其他的方式在多个Servlet中共享，比如使用单例模式处理共享数据。

HttpSession（线程不安全）：HttpSession在用户会话期间存在，只能在处理属于同一个Session请求的线程中被访问，因此理论上访问Session对象的属性是线程安全的。但是当用户打开同属于同一个进程的浏览窗口，对这些窗口的访问属于同一个session，会出现多次请求，需要多个工作线程来处理，可能会造成多个线程同时读写操作。这时我们就需要对属性的读写进行同步处理：使用同步块或读/写器来处理。

ServletRequest（线程安全）：对于每一个请求，由一个线程来执行，都会创建一个新的ServletRequest对象，所以ServletRequest只能在一个线程中被访问。注意：ServletRequest对象在service方法的范围内是有效的，不要试图在service方法结束后仍然保存访问请求对象的引用。

3.  不要在Servlet中创建自己的线程以完成某个功能：servlet本身就是多线程，再创建线程会导致问题复杂化，会带来线程安全的问题。

 

4.  在多个Servlet中对外部对象（比如文件）修改一定要加锁，做到互斥的访问。

 

5.  javax.servlet.SingleThreadModel接口是一个标识接口，如果一个servlet实现了这个接口，那么servlet容器将保证在一个时刻仅有一个线程可以在给定的servlet实例的service方法中执行，将其他所有请求进行排队。

 

6.  服务器可以使用多个实例来处理请求，代替单个实例的请求排队带来的效益问题。服务器创建一个Servlet类的多个Servlet实例组成的实例池，对于每个请求分配Servlet实例进行响应处理，之后放回到实例池中等待下此请求。这样就造成并发访问的问题。此时,局部变量(字段)也是安全的，但对于全局变量和共享数据是不安全的，需要进行同步处理。而对于这样多实例的情况SingleThreadModel接口并不能解决并发访问问题。

 

 

 

 

 

 

 

 

 

 

 

1.javax.servlet.SingleThreadModel接口是一个标识接口，如果一个Servlet类实现了这个接口，那么Servlet容器将保证在同一个时刻只有一个线程可以在给定的servlet实例的service方法中执行。而将其他所有请求进行排队。 

服务器可以使用多个实例来处理请求，代替单个实例的请求排队带来的效益问题。服务器创建一个Servlet类的多个Servlet实例组成的实例池，对于每个请求分配Servlet实例进行响应处理，之后放回到实例池中等待下此请求。这样就造成并发访问的问题。 

此时,局部变量(字段)也是安全的，但对于全局变量和共享数据是不安全的，需要进行同步处理。而对于这样多实例的情况SingleThreadModel接口并不能解决并发访问问题。因此，不建议实现SingleThreadModel接口，因为它在servlet规范中已经被废弃了。 

2.使用同步块Synchronized，防止可能异步调用的代码块。这意味着线程需要排队处理。在使用同板块的时候要尽可能的缩小同步代码的范围，不要直接在sevice方法和响应方法上使用同步，这样会严重影响性能。 

ServletContext是可以多线程同时读/写属性的，线程是不安全的。要对属性的读写进行同步处理或者进行深度Clone()。 

所以在Servlet上下文中尽可能少量保存会被修改（写）的数据，可以采取其他方式在多个Servlet中共享，比方我们可以使用单例模式来处理共享数据。 

HttpSession（线程是不安全的） 

HttpSession对象在用户会话期间存在，只能在处理属于同一个Session的请求的线程中被访问，因此Session对象的属性访问理论上是线程安全的。 

当用户打开多个同属于一个进程的浏览器窗口，在这些窗口的访问属于同一个Session，会出现多次请求，需要多个工作线程来处理请求，可能造成同时多线程读写属性。 

这时我们需要对属性的读写进行同步处理：使用同步块Synchronized和使用读/写器来解决。 

对于每一个请求，ServletRequest由一个工作线程来执行，都会创建有一个新的ServletRequest对象，所以ServletRequest对象只能在一个线程中被访问。所以ServletRequest是线程安全的。ServletRequest对象在service方法的范围内是有效的，不要试图在service方法结束后仍然保存请求对象的引用。 

对于集合， 使用线程安全的Vector代替ArrayList，使用Hashtable代替HashMap。 

不要在Servlet中创建自己的线程来完成某个功能。 

Servlet本身就是多线程的，在Servlet中再创建线程，将导致执行情况复杂化，出现多线程安全问题。 

，在多个servlet中对外部对象(比方文件)进行修改操作一定要加锁，做到互斥的访问 

对于为什么要在doget方法里另上同步块，就是因为解决：当a,b同时访问时，如果a比b稍慢一些就会出现这样的情况，a页面空白，而b页面出现了服务端返回给a的结果，假如是比较敏感的个人信息不能让他人知道 的，而这种情况就会出现严重的安全问题，使用同步块并加锁可以做到a，b访问时两者的信息不会被对方及第三方知道！

 

 

 

 

 

 

 

 

 

 

 

 

我们都知道Servlet是多线程运行的，那么如何让一个Servlet线程安全呢？通常比较常用的措施有如下一些：

1．对于那些特定于某个请求的数据使用局部变量。例如一个登陆应用，每次登陆(也就是一个请求)所采用的用户名和密码可能是不同的，对于这些数据(如用户名、密码)应该使用局部变量来存储，而不应该使用全局变量(即实例变量)。

2．只对那些不会发生变化的数据使用全局变量。

3．对于那些可能被某个请求所改变的实例变量要进行保护，譬如，利用synchronize

   关键字对这些数据进行同步，避免多个线程同时修改同一个实例变量的值。

4．如果Servlet需要访问外部资源，如对文件系统进行读写操作，需要对这些外部资源

   的访问进行同步

除此之外，还有2中其它的方法可以让我们的Servlet线程安全，但是这些做法在真实的web应用中不是很实际，而且往往并不能解决我们的问题。

1．使用SingleThreadModel接口,

这是一个标记接口(Marker Interface)，它并不包含任何需要实现的方法，如Serializable接口也是这样的一个标记接口。如果servlet实现了这个接口，那么就相当于它告诉了servlet容器这样一个信息：我每次只允许我的一个线程在运行。这时候servlet容器会创建一个servlet实例的池，servlet规范允许servlet容器创建多个实现了SingleThreadModel接口的servlet类的实例。当一个请求到达的时候，容器会从池中取出一个servlet的实例来对请求进行处理，此时如果有其它的请求达到，容器不会为这个servlet实例再创建一个线程来对其进行处理，因为这个servlet已经申明为单线程的了。

但是，这并不能保证我们的servlet线程安全，因为静态变量是所有的变量共享的，除此之外，外部资源也可能被多个请求并发访问，因此如果servlet中使用了静态变量、外部资源等，我们仍需同步对它们的访问。

SingleThreadModel的另外一个确定就是伸缩性太差，因为容器创建的servlet实例的数量是有限的，而且所有的实例都需要进行管理，并发请求的数量越大，这种方法也越不适用，毕竟创建一个新的线程比创建一个新的对象要简单多了。

2．将service()、doPost()、doGet()等方法同步

这个方法比使用SingleThreadModel更糟糕，如果我们覆盖service方法并将它同步的话，那就意味着，每次我们的servlet每次只能处理一个请求，因为对于那些没有实现SingleThreadModel接口的servlet类，servlet规范仅允许它们的一个实例存在，也就是所谓的单例。如此一来，当多个请求到达的时候，有的客户端会出现等待的情况。

 

 

 

 

 

 

 

 

 

 

一，servlet容器如何同时处理多个请求。

Servlet采用多线程来处理多个请求同时访问，Servelet容器维护了一个线程池来服务请求。

线程池实际上是等待执行代码的一组线程叫做工作者线程(Worker Thread)，Servlet容器使用一个调度线程来管理工作者线程(Dispatcher Thread)。

 

当容器收到一个访问Servlet的请求，调度者线程从线程池中选出一个工作者线程，将请求传递给该线程，然后由该线程来执行Servlet的service方法。

当这个线程正在执行的时候，容器收到另外一个请求，调度者线程将从池中选出另外一个工作者线程来服务新的请求，容器并不关系这个请求是否访问的是同一个Servlet还是另外一个Servlet。

当容器同时收到对同一Servlet的多个请求，那这个Servlet的service方法将在多线程中并发的执行。

 

 

二，Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间。对于Tomcat可以在server.xml中通过<Connector>元素设置线程池中线程的数目。

 

就实现来说：

  调度者线程类所担负的责任如其名字，该类的责任是调度线程，只需要利用自己的属性完成自己的责任。所以该类是承担了责任的，并且该类的责任又集中到唯一的单体对象中。

而其他对象又依赖于该特定对象所承担的责任，我们就需要得到该特定对象。那该类就是一个单例模式的实现了。

 

三，如何开发线程安全的Servlet                                                                                                                 

 1，变量的线程安全：这里的变量指字段和共享数据(如表单参数值)。

 

  a，将 参数变量 本地化。多线程并不共享局部变量.所以我们要尽可能的在servlet中使用局部变量。

   例如：String user = "";

         user = request.getParameter("user");

 

  b，使用同步块Synchronized，防止可能异步调用的代码块。这意味着线程需要排队处理。

  在使用同板块的时候要尽可能的缩小同步代码的范围，不要直接在sevice方法和响应方法上使用同步，这样会严重影响性能。

 

 

 

 2,属性的线程安全：ServletContext，HttpSession，ServletRequest对象中属性

  ServletContext：（线程是不安全的）

   ServletContext是可以多线程同时读/写属性的，线程是不安全的。要对属性的读写进行同步处理或者进行深度Clone()。

   所以在Servlet上下文中尽可能少量保存会被修改（写）的数据，可以采取其他方式在多个Servlet中共享，比方我们可以使用单例模式来处理共享数据。

  HttpSession：（线程是不安全的）

   HttpSession对象在用户会话期间存在，只能在处理属于同一个Session的请求的线程中被访问，因此Session对象的属性访问理论上是线程安全的。

   当用户打开多个同属于一个进程的浏览器窗口，在这些窗口的访问属于同一个Session，会出现多次请求，需要多个工作线程来处理请求，可能造成同时多线程读写属性。

   这时我们需要对属性的读写进行同步处理：使用同步块Synchronized和使用读/写器来解决。

 

  ServletRequest：（线程是安全的）

   对于每一个请求，由一个工作线程来执行，都会创建有一个新的ServletRequest对象，所以ServletRequest对象只能在一个线程中被访问。ServletRequest是线程安全的。

   注意：ServletRequest对象在service方法的范围内是有效的，不要试图在service方法结束后仍然保存请求对象的引用。

 

 3，使用同步的集合类：

  使用Vector代替ArrayList，使用Hashtable代替HashMap。

 

 4，不要在Servlet中创建自己的线程来完成某个功能。

  Servlet本身就是多线程的，在Servlet中再创建线程，将导致执行情况复杂化，出现多线程安全问题。

 

 5，在多个servlet中对外部对象(比方文件)进行修改操作一定要加锁，做到互斥的访问。 

 

四，SingleThreadModel接口

 javax.servlet.SingleThreadModel接口是一个标识接口，如果一个Servlet实现了这个接口，那Servlet容器将保证在一个时刻仅有一个线程可以在给定的servlet实例的service方法中执行。将其他所有请求进行排队。

 服务器可以使用多个实例来处理请求，代替单个实例的请求排队带来的效益问题。服务器创建一个Servlet类的多个Servlet实例组成的实例池，对于每个请求分配Servlet实例进行响应处理，之后放回到实例池中等待下此请求。这样就造成并发访问的问题。

 此时,局部变量(字段)也是安全的，但对于全局变量和共享数据是不安全的，需要进行同步处理。而对于这样多实例的情况SingleThreadModel接口并不能解决并发访问问题。

 

 SingleThreadModel接口在servlet规范中已经被废弃了。

 

 

 

 

 

 

 

 

 

 

 

这个问题网上一直没有搜到很详细的解释，也可能是高人的解释不符合我的理解方式。所以自己到网上搜集了写资料再加自己的想法，随便写了点东西发到论坛上，希望大家给予修正意见，看我是否理解对了。

 

一般servlet在jvm中只有个对象，当多个请求来请求一个jsp页面的时候，实际上都是调用这个jsp编译好的servlet类doPost或者doGet方法。

 

现在我就模拟一个servlet的调用过程

Java代码  

new Runnalbe{  

    public run(){  

        Request requset = new Request();  

        Resposne response = new Response();  

               //servlet对象只有一个，是容器自动生成的，这里模拟一个servlet的调用过程。  

        servlet.doPost  (request,response);  

    }  

}  

 

当有多个请求过来的时候，相当于多个线程来执行这段代码。上面那个servlet的实现类HelloServlet：

Java代码  

public class HelloServlet extends HttpServlet {  

    private int j =0;  

    public void doPost(HttpServletRequest request, HttpServletResponse response){  

        int i=0;  

        i++;  

        j++;  

        //这里的i和j那个是线程安全的那个不是呢，后面我们将从线程的堆栈，和jvm的堆的概念来解释这个问题  

//request 和 response  对象是不是线程安全的  

   }  

}  

 

JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈（这里的堆栈不是指堆）.也就是说,对于一个Java程序来说，它的运行

就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。

 

我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个

Java方法,JVM就会在线程的Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的。

 

这里还要补充一下堆的概念：

 

堆(heap)是放实例和数组的，JAVA里面没有全局变量这个概念，所有变量都是以类的属性或者参数等形式存在的。GC是自动回收.但是数组和类的引用是放在堆栈中。

 

学过汇编的可能都知道，数据是是存储在栈内的，执行的代码逻辑是可以共用的。当多个线程来访问同一个方法的时候，共享同一段代码逻辑，但是方法对应的数据是存储在各自的堆栈(stack)中，如局部变量和参数还有对象的引用（局部变量和参数也可能是对象的引用）。所以多线程并发的情况下，出现不同步的现象主要是因为各自堆栈存放的某些数据是共享的，说白了就是同一个数据的引用（不是copy）被存放在不同的堆栈中。 例如类X的对象A被多个线程访问，他的引用被保存在多个线程的堆栈中，当多个线程访问A对象的某个属性b的时候如果不加锁就会出现不同步的现象。所以为了避免这种情况发生一是加锁，二就是为每个线程都生成一个类X的对象，这样每个线程的堆栈中存放的类X引用所对应的堆中的对象都不一样，当然就不存在共享的问题。

 

现在我们回到开始那个例子，可以很好的分析出参数request，respone，i是线程安全的，而j是线程不安全的；

为什么？request，respone是线程安全的是因为每个线程对应的request，respone对象都是不一样的，不存在共享问题。i是线程安全的是应为i是局部变量，每个线程的堆栈中存放的值也是各自独立的。

j线程不安全是应为它是类HelloServlet的属性，找了很多资料都不能说清楚它到底放在那里，从实际效果来看，它是不安全的，所以应该是放在和类对象一起放在堆里面的，堆里面估计是复制了一份过来，因为HelloServlet对多个线程而言只有

一个实例，所以存在共享问题。