• 丰搜首页
• 文档中心
• 视频中心
• 丰搜贴吧
• 问题集锦
• 更多功能

选择显示字体大小

• 最大
• 较大
• 标准

构建更有效的web应用

构建更有效的web应用
用train架构动态批量处理用户请求来改善服务器性能
作者：edward salatovka
译者:xmatrix

版权声明：任何获得matrix授权的网站，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:edward salatovka;xmatrix
原文地址:http://www.javaworld.com/javaworld/jw-04-2005/jw-0418-train.html
中文地址:http://www.matrix.org.cn/resource/article/43/43933_efficient_web_application.html
关键词： efficient web application

概要
在这篇文章中，作者edward salatovka介绍了一种他称为train的设计架构。train允许简化组合多用户请求为一次数据库或网络查询，因此改善应用性能和减少硬件需求。这种方式的好处已经通过类似实际应用的压力测试来验证。

想像一下铁路站点以这样一种方式操作，每一个买了票的乘客立刻得到一个专属于他的列车！这种操作方式在实际生活中是可笑的，但在web应用服务器和数据应该访问应用却是很常见的。常规的方式意味着每一个用户请求会得到一个自己的线程和数据库连接。每一个用户请求需要一个即时的数据库或网络资源交互。显然这儿应该使有一种聪明地处理外部通讯的方式而不是增加更多的硬件。让我们寻找一种简单但还未注意到的方式来增加应用的效率。

在这篇文章中，我们采用一种新的方法即每一次与数据库或网络资源交互不是基于每一个请求而多个请求，这样高并发性的负效应如超时和死锁就会大大减少，而且大访问量下的性能衰退也可以忽略不计了。

为了使用这种方式-我们必须创建一个相应的运行应用和执行理论测试的环境。

创建一个黑盒
为了显示这种架构的优越性，我们会构建两个简单的功能上相同的servlet。两者都下发相同的包含从示例数据库获取数据的html页面。每一个servlet代表一种不同的实现—常规的和新式的。为了构建我们的servlet，我们需要一个web应用服务器，一个数据库和一个压力测试器。你可以自己选择相应的软件。这儿我使用的是tomcat 4, jmeter和db2。tomcat 4和jmeter是免费的开源应用。选择db2是为了尽可能模拟商业web环境。

创建数据库并添加随机内容
假设数据库名为“trdata”，我们来创建必要的方案：

//schema.sql
connect to trdata;
create table trentry (id integer not null , name char(25), descr varchar(128), views integer with default 0, constraint p_trentry  primary key (id));

简单的java应用propsamples生成包含250000行随机数据的表trentry。

//propsamples.java
package train;
import java.util.*;
import java.sql.*;
public class propsamples {

  public static string getstring(int size, random rand) {
    stringbuffer strbuff = new stringbuffer();
    for (int i = 0; i < size; i++) {
      char b = (char) (rand.nextint(25) + 65);
      strbuff.append(b);
    }
    return strbuff.tostring();
  }

  public void process() throws sqlexception {
    string sqlstring = &quot;insert into trentry values(?,?,?,?)&quot;;
    connection connection = util.getdbconnection();
    preparedstatement stmt = connection.preparestatement(sqlstring);
    random rand = new random();
    for (int i = 1; i <= 250000; i++) {
      stmt.clearparameters();
      stmt.setint(1, i);
      stmt.setstring(2, getstring(25, rand));
      stmt.setstring(3, getstring(128, rand));
      stmt.setint(4, 0);
      stmt.execute();
      if (i%1000 == 0) {
        connection.commit();
        system.out.println(i + &quot; rows committed&quot;);
      }
    }
  }
  public static void main(string&#91;&#93; args) throws sqlexception{
    propsamples propsamples = new propsamples();
      propsamples.process();
  }
}

这些代码是用来生成数据。util类（可以从资源中下载的源程序中获得）包含db2相关的属性，你可以根据自己的环境而改变。

创建常规的servlet
这儿servlet是最方便的：每一个用户请求由一个独立的轻量级线程来服务，数据库连接可以从连接池中获取，清晰地分离了模型层和视图层等等。下面看一下常规的classicservlet：

// classicservlet.java
package train;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.sql.*;

public class classicservlet
    extends httpservlet {
  int mentrylength = 250000;
  random mrand;
  public void init() throws servletexception {
    mrand = new random(system.currenttimemillis());
  }

  public void doget(httpservletrequest request, httpservletresponse response) throws
      servletexception, ioexception {
    printwriter out = response.getwriter();
    statement stmt = null;
    connection connection = null;
    string name = "";
    string descr = "";
    int views = 0;
    int id = 0;
    boolean iserror = false;
    synchronized (mrand) {
      id = mrand.nextint(mentrylength);
    }
    try {
      connection = util.getdbconnection();
      stmt = connection.createstatement();
      string sqlstr = "select id, name, descr, views from trentry where id =" + id;
      resultset rs = stmt.executequery(sqlstr);
      while (rs.next()) { //retrieves data from from db
        name = rs.getstring("name");
        descr = rs.getstring("descr");
        id = rs.getint("id");

        views = rs.getint("views");
      }
      statement stmtviews = connection.createstatement();
      string sqlviewstr = "update trentry set views = views+1 where id =" + id;
      stmtviews.executeupdate(sqlviewstr); //updates number of the page views
    }
    catch (sqlexception ex) {iserror = true;}
    finally {
      try {
        if (stmt != null) {
          stmt.close();
        }
        if (connection != null) {
          connection.commit();
          connection.close();
        }
      }
      catch (sqlexception ex1) {iserror = true;}
    }
    if (iserror) {
      out.println(&quot;<html>system error</html>&quot;);
    }
    else { //delivers html page to browser
      out.println(&quot;<html>&quot;);
      out.println(&quot;<p>id: &quot; + id + &quot;</p>&quot;);
      out.println(&quot;<p>name: &quot; + name + &quot;</p>&quot;);
      out.println(&quot;<p>description: &quot; + descr + &quot;</p>&quot;);
      out.println(&quot;<p>views: &quot; + views + &quot;</p>&quot;);
      out.println(&quot;</body></html>&quot;);
    }
  }

}

我发布了这个servlet，在游览器中输入http://localhost:8080/train/classicservlet，就可以得到下面的页面：
id: 178866
name: xeirvypsftnrxyewqwskoopes
description: jbgpgksmdqkvxvpjcxkimwlewjabsgbntoyrxrkumdbwoyociakdwggebhkifongsrbibjihsbngeyio
rkgfovwyxyxxjkubblvbskoklfchigrugrokesijqferwjtv
views: 0

就这些而已，但这已经很好地模拟了电子商务中的常规操作。servlet从数据库中获取无意义的数据，更新访问者的数目并输出结果。请注意我们生成随机的键值来从trentry表中获取随机行数据。一个好的数据库管理系统通常会缓存数据。因此，第二次的相同的select语句会执行地更快。我们使用随机键的目的就是使我们的数据不被缓存从而使下面的性能测试更精确。

常规servlet性能
那么这种servlet执行的效果如何呢？我们用jmeter来测试一下。使用jmeter模拟50个并发用户，他们将在5分钟内访问servlet6次。
为了使tomcat在大访问量下正常工作，我必须修改tomcat的配置文件server.xml，修改连接数据参数为簃axprocessors="150"，acceptcount="150"

图1是jmeter结果图的快照，显示了测试的性能结果。


figure 1. conventional servlet performance. click on thumbnail to view full-sized image.

结果很明显：平均每次请求执行的时间为2.2秒（当然，如果我们使用预编译语句和连接池的话结果会更好一些）。而在我只模拟一个用户时，执行时间仅为70毫秒。因此，我们可以确定在常规servlet方式中大访问量将导致性能的明显下降。

train模式的实现
类推我们的铁路站点，让我们在servlet中尝试一下相同的感觉。如果用户的请求必须等待一次有计划的与数据库的交互而且依赖其他的请求时会怎么样？这种功能很容易用jdbc2.0代码来实现：

statement.addbatch();  //load the first passenger
statement.addbatch(); // load the second passenger
…
statement.executebatch(); //train is departing

这段代码是一种常用的用来减少与数据交互次数的技巧。
一种更有效的方式是组合多个sql语句成一个，这样就可以不仅减少与数据库交互的次数而且减少查询的次数。例如，两个不同的select语句select * from trentry where id=333 和 select * from trentry where id=266可以用select * from trentry where id in (333,266)来代替。这样的话，更多的用户请求可以用一次事务范围内的一个sql语句来完成。

此外，随着性能的提高，体现了另一个好处：这种技术减少了死锁和超时！更少的数据库连接，更少的排他锁，更少的死锁和超时。

有时候是不可能将多个sql语句组合成一个（如一个普通的更新语句）。那我们就必须使用statement.addbatch()方法。
train方式组合了这两种方法。

行胜于言
图2中的时序图及步骤列表解释了这个设计的原理。


figure 2. sequence diagram of the train pattern. click on thumbnail to view full-sized image.


·        trainservlet实例化job对象，发送job对象到dispatcher，然后暂停
·        dispatcher组合job到批处理中。
·        对每一个批处理，dispatche创建一个worker类的实例。
·        在给定时间或批处理中包含一定数量的job后，worker生成sql语句并与数据库交互。
·        每一个sql语句执行批处理中与所有job相关的任务。
·        worker中断trainsevlet线程
·        trainsevlet下发结果给用户。

现在我们打算解剖一下这种设计的实际实现。
我们来看一下下面的servlet：

//trainservlet.java
package train;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class trainservlet extends httpservlet {
  int mentrylength=250000;
  dispatcher mdispatcher;
  random mrand;
  public void init() throws servletexception {
    mrand = new random(system.currenttimemillis());
    mdispatcher = new dispatcher();
    thread ht = new thread(mdispatcher); //instantiate and execute in the separate thread.
    ht.start();
  }
  public void doget(httpservletrequest request, httpservletresponse response) throws         servletexception, ioexception {
    int id=0;
    synchronized(mrand){
      id=mrand.nextint(mentrylength);
    }
    job job = new job(string.valueof(id)); //each concurrent request creates job instance.
    job.mjobthread = thread.currentthread(); //job should know the thread of the request.
    printwriter out = response.getwriter(); //job should know the output stream of the browser.
    job.mout = out;
    mdispatcher.addjob(job); //job is sent to the dispatcher.
   //dispatcher is a container for all concurrent jobs.
    try {
        thread.sleep(100000); //let's wait until database interaction is finished.
        system.out.println("error: request is timed out"); //too bad. 100 seconds was not enough.
    }
    catch (interruptedexception ex2) {
            //success! members of the job instances are populated.
    }
    job.marshall(); // let's display the page in the browser.
}
}

新的servlet类似classicservlet，但有一些不同：用户请求被包含在job类的实例中，与数据库的交互由dispatcher类的实例来处理。
job类显示如下：

//job.java
package train;
import java.io.*;
public class job {
  string mname;
  string mdescr;
  int mviews;
  string mid;
  printwriter mout;
  thread mjobthread;
  boolean mhasfailed = false;
  //sorry, no getters and setters to save space
  
  public job(string id) {
    mid = id;
  }

  public void marshall(){ // displays html page
   mout.println(&quot;<html><body>&quot;);
   if(mhasfailed){
     mout.println(&quot;system error&quot;);
   }else{
   mout.println(&quot;<p>id: &quot;+mid+&quot;</p>&quot;);
   mout.println(&quot;<p>name: &quot;+mname+&quot;</p>&quot;);
   mout.println(&quot;<p>description: &quot;+mdescr+&quot;</p>&quot;);
   mout.println(&quot;<p>views: &quot;+mviews+&quot;</p>&quot;);
   }
   mout.println(&quot;</body></html>&quot;);
  }
}

job是一个纯粹的用户请求的代表。
marshall()方法在浏览器中显示信息。mjobthread成员是一个由web应用服务器创建执行请求的线程。
dispatcher类是最重要的但也很简单：

//dispatcher.java
package train;

import java.util.*;
public class dispatcher
    implements runnable {
  private list mcurrentjobbatch = new arraylist(); //batch container
  private int mjobbatchmaxsize = 5; //maximum number of the jobs in the batch
  private int mintervaltime = 50; //maximum time to wait before batch execution

  public synchronized void addjob(job job) {
    mcurrentjobbatch.add(job);
    if (mcurrentjobbatch.size() == mjobbatchmaxsize) {
      processjobbatch(); //if batch is full, execute
    }
  }

  private synchronized void processjobbatch() {
    if (mcurrentjobbatch.size() == 0) { return; }
    worker worker = new worker(mcurrentjobbatch);
    thread ht = new thread(worker);
    ht.start();
    mcurrentjobbatch = new arraylist();
  }

  public void run() {
    try {
      while (true) {
        thread.sleep(mintervaltime);
        processjobbatch(); // each  mintervaltime milliseconds execute batch
      }
    }
    catch (interruptedexception ex) { }
  }
} 

dispatcher生存在一个独立的线程中并且是所有并发job的容器。每一批处理在两种条件下会执行，不考虑先后：
1、        自上一次这种条件下执行后mintervaltime毫秒并且至少有一个job在批次中。
2、        批次的大小达到mjobbatchmaxsize
如果mjobbatchmaxsize值设为1，trainservlet就退化为classicservlet。这是一个动态批处理的重要标识，这会在稍后解释。
方案的最后部分是worker类：

//worker.java
package train;

import java.util.*;
import java.sql.*;

public class worker
    implements runnable {
  list mjobs;
  map mjobmap; //helper member for mapping the jobs 
  protected worker(list jobs) {
    mjobs = jobs;
    mjobmap = new hashmap();
  }

  private void process() {
    boolean iserror = false;
    stringbuffer sqlbuff = new stringbuffer(
        "select id,name ,descr,views from trentry where id in ");
    stringbuffer whereclause = createwhereclause(); //
    sqlbuff.append(whereclause);
    /* now sql statement is fully formed and looks like:

     select id,name ,descr,views from trentry where id in (3343,22222,5555).
         this will allow us to fetch several user requests in one shot */
    connection connection = null;
    statement stmt = null;
    try {
      connection = util.getdbconnection();
      stmt = connection.createstatement();
      resultset rs = stmt.executequery(sqlbuff.tostring());
      system.out.println(sqlbuff.tostring());
      map result = new hashmap();
      while (rs.next()) {
        int id = rs.getint("id");
        string name = rs.getstring("name");
        string descr = rs.getstring("descr");
        int views = rs.getint("views");
        job job = (job) mjobmap.get(string.valueof(id));
        //populate instance of the job with data retrieved from database
        job.mname = name;
        job.mdescr = descr;
        job.mviews = views;
      }
      string sqlviewstr = "update trentry set views = views+1 where id in " +
          whereclause;
      // the same trick for update statement
      stmt.executeupdate(sqlviewstr);
    }
    catch (sqlexception ex) {
      iserror = true;
    }
    finally {
      try {

        if (stmt != null) {
          stmt.close();
        }
        if (connection != null) {
          if (iserror) {
            connection.rollback();

          }
          else {
            connection.commit();
          }
          connection.close();
        }
      }
      catch (sqlexception ex1) { iserror = true; }
    }
    finishjobs(iserror);
    return;
  }

  private stringbuffer createwhereclause() {
    stringbuffer clause = new stringbuffer("(");
    for (int i = 0; i < mjobs.size(); i++) {
      job job = (job) mjobs.get(i);
      string id = job.mid;
      if (i != 0) {
        clause.append(&quot;,&quot;);
      }
      clause.append(id);
      mjobmap.put(id, job);
    }
    clause.append(&quot;)&quot;);
    return clause;
  }

  private void finishjobs(boolean iserror) {
    for (int i = 0; i < mjobs.size(); i++) {
      job job = (job) mjobs.get(i);
      if (iserror) {
        job.mhasfailed=true; //rudimentary error handling
      }
      job.mjobthread.interrupt();
     /* wake up the trainservlet to deliver the page to the browser */
    }
  }

  public void run() {
    process();
  }
}

worker类创建sql语句，为一次与数据库的交互来组合job，用来自数据库的信息生成job实例并且唤醒job线程。

train servlet性能
我使用相同的jmeter配置来测试trainservlet。是否我们在浪费时间来开发train模式呢？当然不是，就如图3显示的那样。


figure 3. trainservlet performance. click on thumbnail to view full-sized image.

我们提高了15倍的效率！结果可能与硬件/软件/特定的实现有关，但显然效率的提高是肯定的。
这个图描述了静态的50个用户并发访问的模拟环境。但更实际和有意义的数据可以通过动态回归分析来取得。对这种类型的分析，我模拟了不同的并发用户数据并且测量两种servlet对每个请求的性能。

图4显示了测量结果。


figure 4. comparative dynamic performance. click on thumbnail to view full-sized image.

结果有点难心置信。相比classicservlet，trainservlet在大量外部访问时并没有出现性能衰退。当然在小于3个并发用户时，classicservlet的响应更快一些。我称这种现象为低访问量惩罚，这出现在只有一个用户请求时。在这种情况下，我们需要等到下一次计划时间到达时才能执行，也就是说在只有一个请求时批处理并不能提供什么好处。

最后的探讨
这儿描述的这种方案因为简洁的原因写得相当简单，有一些地方明显值得改善。

前瞻性的访问量分析和动态批处理
在这里我们设置mintervaltime的值为50毫秒。假设访问量很小，平均100毫秒才有一个新的请求，那么我们将会延迟每个请求将近25毫秒。我们如何才能以免这种低访问量惩罚呢？解决方案来自基于前瞻性访问量分析的动态批处理。换句话说，我们根据前一次会话中的用户请求数来可以改变批处理中的最工作数据。最简单的算法如下：
1、        记下最近50毫秒内服务的请求数量。
2、        如果数据小于5，则设置mjobbatchmaxsize为1否则为5。

如我上面讨论的，当mjobbatchmaxsize为1时，trainservlet就与classicservle一样了。

多个命令的分配器
标准web应用服务器处理多个命令而不是一个，实际应用中dispatcher和worker应该能为所有的服务。每一个命令应该有自己的worker类，dispatcher应该作为一个单例来实现。然而，这儿两种可能的dispatcher设计方式：
1、        每一个命令有一个自己的dispatcher类。如果特定时间后，没有请求需要服务则dispatcher线程就退出，因为我们不需要很多空闭的线程来消耗系统资源。因此对比在serverlet的init()方法中实例化dispatcher，我们更倾向于调用：dispatcher.getintance().addjob(job)。
2、        仅有一个类来管理来自不同命令的不同批处理并且通过命令名将他们与相关的工作者相关联。这时候，调用看起来更像：dispatcher.getinstance().addjob(this.getclass().getname(),job).

作为jdbc代理的train模式
从实际的观点来看，想从运行中的标准应用或者放弃传统的想法来重新构建应用是困难的。那么如果构建某种jdbc代理使得来自应用的jdbc调用基本一致时会怎么样呢？可以用ejb作为包装器来处理。这种方式是有效的，因为他可以处理任何如并发用户访问网络资源或数据库的应用而不只是服务于web应用。但是这已经是另一个主题了。

小结
在这篇文章中，我们设计了一种新的称为train的方式来开发有效的web应用。我们基于train模式构建了一个实际的应用并且证明他可以在压力测试提供100%的性能改善。train模式的使用并不限于web应用，通过减少软硬件的需求，他可以为任何处理并发用户访问网络资源或数据库的应用带来好处。
在这里特别感谢我的朋友们mark jackson, sander berents, tom griffin, and eric van stegeren对我的支持和帮助。

关于作者
edward salatovka是一个工作于专利信息提供商的高级主管工程师。
thomson delphion最近12年他作为核心开发人员、技术领导及架构师工作于大型项目如ibm的websphere commerce和后续的高技术启动的创新的解决方案

资源
·javaworld.com:javaworld.com
·matrix-java开发者社区:http://www.matrix.org.cn/
·下载本文示例代码:http://www.javaworld.com/javaworld/jw-04-2005/train/jw-0418-train.zip
·来自java开发人员almanac的“在数据库中执批量sql语句”:http://javaalmanac.com/egs/java.sql/batchupdate.html

 

关键字 本文所属关键字

相关 与本文相关文章

分类 所有文章关键字导航

标准 网站致力的规范