Servlet及JSP中的多线程同步问题

Servlet/JSP技术和ASP、PHP等相比，由于其多线程运行而具有很高的执行效率。由于Servlet/JSP默认是以多线程模式执行的，所以，在编写代码时需要非常细致地考虑多线程的同步问题。然而，很多人编写Servlet/JSP程序时并没有注意到多线程同步的问题，这往往造成编写的程序在少量用户访问时没有任何问题，而在并发用户上升到一定值时，就会经常出现一些莫明其妙的问题，对于这类随机性的问题调试难度也很大。

　　 一、在Servlet/JSP中的几种变量类型

　　在编写Servlet/JSP程序时，对实例变量一定要小心使用。因为实例变量是非线程安全的。在Servlet/JSP中，变量可以归为下面的几类：

　　 1. 类变量

　　request，response，session，config，application，以及JSP页面内置的page, pageContext。其中除了application外，其它都是线程安全的。

　　 2. 实例变量

　　实例变量是实例所有的，在堆中分配。在Servlet/JSP容器中，一般仅实例化一个Servlet/JSP实例，启动多个该实例的线程来处理请求。而实例变量是该实例所有的线程所共享，所以，实例变量不是线程安全的。

　　 3. 局部变量

　　局部变量在堆栈中分配，因为每一个线程有自己的执行堆栈，所以，局部变量是线程安全的。

　　 二、在Servlet/JSP中的多线程同步问题

　　在JSP中，使用实例变量要特别谨慎。首先请看下面的代码：

// instanceconcurrenttest.jsp <%@ page contentType="text/html;charset=GBK" %> <%! //定义实例变量 String username; String password; java.io.PrintWriter output; %> <% //从request中获取参数 username = request.getParameter("username"); password = request.getParameter("password"); output = response.getWriter(); showUserInfo(); %> <%! public void showUserInfo() { //为了突出并发问题，在这儿首先执行一个费时操作 int i =0; double sum = 0.0; while (i++ < 200000000) { sum += i; } output.println(Thread.currentThread().getName() + "<br>"); output.println("username:" + username + "<br>"); output.println("password:" + password + "<br>"); } %>

　　在这个页面中，首先定义了两个实例变量，username和password。然后在从request中获取这两个参数，并调用showUserInfo()方法将请求用户的信息回显在该客户的浏览器上。在一个用户访问是，不存在问题。但在多个用户并发访问时，就会出现其它用户的信息显示在另外一些用户的浏览器上的问题。这是一个严重的问题。为了突出并发问题，便于测试、观察，我们在回显用户信息时执行了一个模拟的费时操作，比如，下面的两个用户同时访问（可以启动两个IE浏览器，或者在两台机器上同时访问）：

a： http://localhost:8080/instanceconcurrenttest.jsp?username=a&password=123

b： http://localhost:8080/instanceconcurrenttest.jsp?username=b&password=456

如果a点击链接后，b再点击链接，那么，a将返回一个空白屏幕，b则得到a以及b两个线程的输出。请看下面的屏幕截图：



图1：a的屏幕



图2：b的屏幕

　　从运行结果的截图上可以看到，Web服务器启动了两个线程分别来处理来自a和b的请求，但是在a却得到一个空白的屏幕。这是因为上面程序中的output, username和password都是实例变量，是所有线程共享的。在a访问该页面后，将output设置为a的输出，username,password分别置为a的信息，而在a执行printUserInfo()输出username和password信息前，b又访问了该页面，把username和password置为了b的信息，并把输出output指向到了b。随后a的线程打印时，就打印到了b的屏幕了，并且，a的用户名和密码也被b的取代。请参加下图所示：



图3：a、b两个线程的时间线

　　而实际程序中，由于设置实例变量，使用实例变量这两个时间点非常接近，所以，像本例的同步问题并没有这么突出，可能会偶尔出现，但这却更加具有危险性，也更加难于调试。

　　同样，对于Servlet也存在实例变量的多线程问题，请看上面页面的Servlet版：

// InstanceConcurrentTest.java import javax.servlet.*; import javax.servlet.http.*; import java.io.PrintWriter; public class InstanceConcurrentTest extends HttpServlet { String username; String password; PrintWriter out; public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,java.io.IOException { //从request中获取参数 username = request.getParameter("username"); password = request.getParameter("password"); System.out.println(Thread.currentThread().getName() + " | set username:" + username); out = response.getWriter(); showUserInfo(); } public void showUserInfo() { //为了突出并发问题，在这儿首先执行一个费时操作 int i =0; double sum = 0.0; while (i++ < 200000000) { sum += i; } out.println("thread:" + Thread.currentThread().getName()); out.println("username:"+ username); out.println("password:" + password); } }

　　 三、解决方案

　　 1. 以单线程运行Servlet/JSP

　　在JSP中，通过设置： ，在Servlet中，通过实现javax.servlet.SingleThreadModel，此时Web容器将保证JSP或Servlet实例以单线程方式运行。

　　重要提示：在测试中发现，Tomcat 4.1.17不能正确支持isThreadSafe属性，所以，指定isTheadSafe为false后，在Tomcat 4.1.17中仍然出现多线程问题，这是Tomcat 4.1.17的Bug。在Tomcat 3.3.1和Resin 2.1.5中测试通过。

　　 2. 去除实例变量，通过参数传递

　　从上面的分析可见，应该在Servlet/JSP中尽量避免使用实例变量。比如，下面的修正代码，去除了实例变量，通过定义局部变量，并参数进行传递。这样，由于局部变量是在线程的堆栈中进行分配的，所以是线程安全的。不会出现多线程同步的问题。代码如下：

<%@ page contentType="text/html;charset=GBK" %> <% //使用局部变量 String username; String password; java.io.PrintWriter output; //从request中获取参数 username = request.getParameter("username"); password = request.getParameter("password"); output = response.getWriter(); showUserInfo(output, username, password); %> <%! public void showUserInfo(java.io.PrintWriter _output, String _username, String _password) { //为了突出并发问题，在这儿首先执行一个费时操作 int i =0; double sum = 0.0; while (i++ < 200000000) { sum += i; } _output.println(Thread.currentThread().getName() + "<br>"); _output.println("username:" + _username + "<br>"); _output.println("password:" + _password + "<br>"); } %>

注：有的资料上指出在printUserInfo()方法或者实例变量的相关操作语句上使用synchronized关键字进行同步，但这样并不能解决多线程的问题。因为，这样虽然可以使对实例变量的操作代码进行同步，但并不能阻止一个线程使用另外一个线程修改后的“脏的”实例变量。所以，除了降低运行效率外，不会起到预期效果。 

 

 

 

 

摘 要：介绍了Servlet多线程机制，通过一个实例并结合Java 的 内存 模型说明引起Servlet线程不安全的原因，给出了保证Servlet线程安全的三种 解决方案 ，并说明三种方案在实际开发中的取舍。

　　关键字：Servlet 线程安全 同步 Java内存模型 实例变量

　　Servlet/JSP技术和ASP、PHP等相比，由于其多线程运行而具有很高的执行效率。由于Servlet/JSP默认是以多线程模式执行的，所以，在编写代码时需要非常细致地考虑多线程的安全性问题。然而，很多人编写Servlet/JSP程序时并没有注意到多线程安全性的问题，这往往造成编写的程序在少量用户访问时没有任何问题，而在并发用户上升到一定值时，就会经常出现一些莫明其妙的问题。

　　Servlet的多线程机制

　　Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。当客户端第一次请求某个Servlet时，Servlet容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时，一般不会再实例化该Servlet类，也就是有多个线程在使用这个实例。Servlet容器会自动使用线程池等技术来支持系统的运行，如图1所示。

　　

　　图1 Servlet线程池

　　这样，当两个或多个线程同时访问同一个Servlet时，可能会发生多个线程同时访问同一资源的情况，数据可能会变得不一致。所以在用Servlet构建的Web应用时如果不注意线程安全的问题，会使所写的Servlet程序有难以发现的错误。

　　Servlet的线程安全问题

　　Servlet的线程安全问题主要是由于实例变量使用不当而引起的，这里以一个现实的例子来说明。

Import javax.servlet. *;
Import javax.servlet.http. *;
Import java.io. *;
Public class Concurrent Test extends HttpServlet {PrintWriter output;
Public void service (HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {String username;
Response.setContentType ("text/html; charset=gb2312");
Username = request.getParameter ("username");
Output = response.getWriter ();
Try {Thread. sleep (5000); //为了突出并发问题，在这设置一个延时
} Catch (Interrupted Exception e){}
output.println("用户名:"+Username+"<BR>");
}
}

　　该Servlet中定义了一个实例变量output，在service方法将其赋值为用户的 输出 。当一个用户访问该Servlet时，程序会正常的运行，但当多个用户并发访问时，就可能会出现其它用户的信息显示在另外一些用户的浏览器上的问题。这是一个严重的问题。为了突出并发问题，便于测试、观察，我们在回显用户信息时执行了一个延时的操作。假设已在web.xml配置文件中注册了该Servlet，现有两个用户a和b同时访问该Servlet（可以启动两个IE浏览器，或者在两台机器上同时访问）,即同时在浏览器中输入：

　　a： http://localhost: 8080/servlet/ConcurrentTest? Username=a

　　b： http://localhost: 8080/servlet/ConcurrentTest? Username=b

　　如果用户b比用户a回车的时间稍慢一点，将得到如图2所示的输出：

　　

　　图2 a用户和b用户的浏览器输出

　　从图2中可以看到，Web 服务器 启动了两个线程分别处理来自用户a和用户b的请求，但是在用户a的浏览器上却得到一个空白的屏幕，用户a的信息显示在用户b的浏览器上。该Servlet存在线程不安全问题。下面我们就从分析该实例的内存模型入手,观察不同时刻实例变量output的值来分析使该Servlet线程不安全的原因。

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

　　

　　图3 Servlet实例的JMM模型

　　下面根据图3所示的内存模型，来分析当用户a和b的线程（简称为a线程、b线程）并发执行时，Servlet实例中所涉及变量的变化情况及线程的执行情况，如图4所示。

调度时刻	a线程	b线程
T1	访问Servlet页面
T2		访问Servlet页面
T3	output=a的输出username=a休眠5000毫秒，让出CPU
T4		output=b的输出（写回主存）username=b休眠5000毫秒，让出CPU
T5	在用户b的浏览器上输出a线程的username的值,a线程终止。
T6		在用户b的浏览器上输出b线程的username的值,b线程终止。

　　图4 Servlet实例的线程调度情况

　　从图4中可以清楚的看到，由于b线程对实例变量output的修改覆盖了a线程对实例变量output的修改，从而导致了用户a的信息显示在了用户b的浏览器上。如果在a线程执行输出语句时，b线程对output的修改还没有刷新到主存，那么将不会出现图2所示的输出结果，因此这只是一种偶然现象，但这更增加了程序潜在的危险性。

　　设计线程安全的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+"<BR>");
}
}
}

　　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 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。

　　小结

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

 

 

 

 

最小化 servlet 中同步的使用。因为 servlet 是多线程的，主要代码路径的同步会严重地且极为有害地影响性能。

建议

servlet 是多线程的。基于 servlet 的应用程序必须认识并适当地处理这一点。如果应用程序有很多大段的代码是同步的，那么这个应用程序实际上就变成单线程的，而且吞吐量会显著下降。

在 servlet 中不出现同步是最佳选择，然而，如果应用程序设计无法避免同步，那么请使用“锁对象（lock Object）”并且锁定可用性最小的代码路径。请不要同步 servlet 的 service 方法或 doGet 以及 doPost 方法。这些方法是主要代码路径。同步这些方法或任何这些 servlet 方法之一将锁定整个 servlet 实例。下列代码显示了一个使用“锁对象”来保护 servlet 实例变量 numberOfRows 的示例。

最小同步代码路径

public class BpAllBadThingsServletsV1b extends HttpServlet
{
private int numberOfRows = 0;
private javax.sql.DataSource ds = null;

private Object lockObject = new Object();

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
Connection conn = null;
ResultSet rs = null;
PreparedStatement pStmt = null;
int startingRows = 0;

synchronize(lockObject)
{
startingRows = numberOfRows;
}
try
{
String employeeInformation = null;
conn = ds.getConnection("db2admin", "db2admin");
pStmt = conn.prepareStatement
("select * from db2admin.employee");
rs = pStmt.executeQuery();
}
catch (Exception es)
{
// Error handling code here
}
}
}

应被取代的方法

以下代码显示如何同步主要代码路径来保护称为 numberOfRows 的 servlet 实例变量。

使用 javax.servlet.SingleThreadModel 仍是另一种保护 servlet 实例变量的方法，但最好还是避免使用这种方法。

下面的图 1 显示了同步的性能影响

锁定主要代码路径：过度的同步

public class BpAllBadThingsServletsV1a extends HttpServlet
{
private int numberOfRows = 0;
private javax.sql.DataSource ds = null;

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
Connection conn = null;
ResultSet rs = null;
PreparedStatement pStmt = null;
int startingRows;

try
{
synchronized(this) // Locks out Most of the Servlet Processing
{
startingRows = numberOfRows;
String employeeInformation = null;
conn = ds.getConnection("db2admin", "db2admin");
pStmt = conn.prepareStatement
("select * from db2admin.employee");
rs = pStmt.executeQuery();
}
}
catch (Exception es)
{
// Error handling code here
}
}
}