1.1.1. 通过JNDI找到JavaMail
1.1.1.1. 使用远程访问获得JavaMail
 Hashtable env=new Hashtable();
 env.put(Context.INITIAL_CONTEXT_FACTORY,"com.apusic.naming.jndi.CNContextFactory");
 env.put(Context.PROVIDER_URL,"iiop://localhost:6888");
 //插入相关验证信息
 env.put(Context.SECURITY_CREDENTIALS,"admin" ) ;
 env.put(Context.SECURITY_PRINCIPAL,"admin");
 Context initCtx=new InitialContext(env);
 System.out.println(initCtx.PROVIDER_URL);
 //通过RMI 取得
 Session myMailSession = (Session) initCtx.lookup("javamail/myMailNoAuth");
1.1.1.2. 使用Apusic默认方式获得JavaMail
 Context initCtx = new InitialContext();
 Session myMailSession = (Session) initCtx.lookup("javamail/myMailNoAuth");
 System.out.println(myMailSession.getProperty("mail.smtp.host"));
 
1.1.2. 通过资源注入配置JavaMail
 @Resource(mappedName = "javamail/myMailAuth", type = javax.mail.Session.class, shareable = true, authenticationType = Resource.AuthenticationType.CONTAINER, description = "my email with auth")
 private Session myAuthMailSession;
或者
 @Resource(mappedName = "javamail/myMailAuth")
 private Session myAuthMailSession;

1.2. 在代码中初始化
1.2.1. 无须认证的初始化
 final Properties props = new Properties();
 props.put("mail.transport.protocol", "smtp");
 props.put("mail.smtp.auth", "false");
 props.put("mail.smtp.host", "localhost");
 Session myMailSession = Session.getInstance(props);
1.2.2. 需要认证的初始化
 final Properties props = new Properties();
 props.put("mail.transport.protocol", "smtp");
 props.put("mail.smtp.auth", "true");
 props.put("mail.smtp.host", "smtp.163.com");
 Session myMailSession = Session.getInstance(props, new Authenticator() {
  public PasswordAuthentication getPasswordAuthentication() {
   return new PasswordAuthentication("user", "password");} });

1.4. 对Session调试的配置
● 可以在mail-session中加入<property name="mail.debug" value="true" />
● 可以在Session初始化前加入props.put("mail.debug", "true");
● 可以在Session初始化后,通过代码控制myMailSession.setDebug(true);

1.5. Properties的解释
◆ mail.store.protocol：用于检索邮件的协议
◆ mail.transport.protocol：用于传送邮件的协议
◆ mail.host：默认的主机名，默认是本地计算机。
◆ mail.user：默认的用户名。
◆ mail.from：默认的返回地址。
◆ mail.debug：是否输出DEBUG信息。默认为False。
◆ mail.protocol.host：指定协议的主机名，没有指定就用mail.host。例如：mail.smtp.host=smtp.163.com
◆ mail.protocol.user：指定协议的用户名，没有指定就用mail.user。例如：mail.smtp.user=user
◆ mail.protocol.from：指定协议的返回地址，没有指定就用mail.from。例如：mail.smtp.from=user@163.com
◆ mail.smtp.auth：如果是True，就会登录SMTP服务器，获得授权才能发送邮件。默认为False。

2. 通过JavaMail发送邮件
2.1. 通过无须认证的SMTP发邮件
  final Properties props = new Properties();
  props.put("mail.transport.protocol", "smtp");
  props.put("mail.smtp.auth", "false");
  props.put("mail.smtp.host", "localhost");
  try {
   Session myMailSession = Session.getInstance(props);
   myMailSession.setDebug(true); // 打开DEBUG模式
   Message msg = new MimeMessage(myMailSession);
   msg.setFrom(new InternetAddress("user@163.com"));
   msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("zhuyuanxiang@apusic.com"));
   msg.setContent("I have a email test!", "text/plain");
   msg.setSentDate(new java.util.Date());
   msg.setSubject("Test");
   msg.setText("This is a test!\n");
   System.out.println("1.Please wait for sending one...");

   // 发送邮件
   // javax.mail.Transport.send(msg); // 与下面四行的功能一样
   javax.mail.Transport myTransport = myMailSession.getTransport("smtp");
   myTransport.connect();
   myTransport.sendMessage(msg, msg.getRecipients(Message.RecipientType.TO));
   myTransport.close();
   
   System.out.println("2.Your message had send!");
  } catch (Exception error) {
   System.out.println("*.I am sorry to tell you the fail for " + error);
  }

注：测试可以使用Microsft IIS SMTP 服务，安装好启动服务后，还需要进入“IIS管理器”，增加一个“远程域”，对于“远程域”的“出站安全性”需要把用户名和密码加上（就是平时发邮件时登录用的用户名／密码），否则邮件发不出去。

2.2. 通过需要认证的SMTP发邮件
2.2.1. 默认方式初始化Session
  final Properties props = new Properties();
  props.put("mail.transport.protocol", "smtp");
  props.put("mail.smtp.auth", "true");

  try {
   Session myMailSession = Session.getInstance(props);
   myMailSession.setDebug(true); // 打开DEBUG模式
   Message msg = new MimeMessage(myMailSession);
   msg.setFrom(new InternetAddress("user@163.com"));
   msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("zhuyuanxiang@apusic.com"));
   msg.setContent("I have a email test!", "text/plain");
   msg.setSentDate(new java.util.Date());
   msg.setSubject("Test");
   msg.setText("This is a test!\n");
   System.out.println("1.Please wait for sending two...");

   // 发送邮件
   javax.mail.Transport myTransport = myMailSession.getTransport("smtp");
   myTransport.connect("smtp.163.com", "user", "password");
   myTransport.sendMessage(msg, msg.getRecipients(Message.RecipientType.TO));
   myTransport.close();
   // javax.mail.Transport.send(msg); // 这行不能使用。
   System.out.println("2.Your message had send!");
  } catch (Exception error) {
   System.out.println("*.I am sorry to tell you the fail for " + error);
  }
 }

2.2.2. 嵌入认证类初始化Session
 final Properties props = new Properties();
 props.put("mail.transport.protocol", "smtp");
 props.put("mail.smtp.auth", "true");
 props.put("mail.smtp.host", "smtp.163.com");

 try {
  Session myMailSession = Session.getInstance(props, new Authenticator() {
   public PasswordAuthentication getPasswordAuthentication() {
    return new PasswordAuthentication("user", "password");
   }
  });
  myMailSession.setDebug(true); // 打开DEBUG模式
  InternetAddress address = new InternetAddress("user@163.com");
  String message = "I have a email test!";
  Message msg = new MimeMessage(myMailSession);
  msg.setFrom(address);
  msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("zhuyuanxiang@apusic.com"));
  msg.setContent(message, "text/plain");
  msg.setSentDate(new java.util.Date());
  msg.setSubject("Test");
  msg.setText("This is a test!\n");
  out.println("1.Please wait for sending...");
  
  // 发送邮件
  javax.mail.Transport myTransport = myMailSession.getTransport("smtp");
  myTransport.connect();
  myTransport.sendMessage(msg, msg.getRecipients(Message.RecipientType.TO));
  myTransport.close();
  // javax.mail.Transport.send(msg); // 注释上四行，打开这行代码，功能一样
  out.println("2.Your message had send!");
 } catch (Exception error) {
  out.println("*.I am sorry to tell you the fail for " + error);
 }

注：资源注入的Session发送邮件时：
无须认证的SMTP，可以参考2.1.
需要认证的SMTP，可以参考2.2.1.

参考：
http://java.sun.com/products/javamail/javadocs/com/sun/mail/smtp/package-summary.html
http://commons.apache.org/email/userguide.html
http://www.blogjava.net/Unmi/archive/2007/06/07/124179.html
http://unmi.blogcn.com/diary,117630488.shtml

Apusic Stduio打包的示例工程。
http://zhuyuanxiang.javaeye.com/topics/download/d6f5c3a9-9cd9-30be-9b64-9e311900b304

备注：本文耗时1周完成。

★ 为什么要资源注入？
大多数企业级java应用程序都使用了诸如DataSources,EJBs或WebService的外在的资源和服务，在J2EE 1.4中，用户必须在部署描述符中明确声明所依赖的资源或者使用JNDI的lookup方法去获得资源的引用。

最初目的是为了减少应用与资源的依赖度，具体可以参考IoC（控制反转）和DI（依赖注入），但现在作者认为优点很多：
1. 减少应用与资源的依赖度，便于应用的后期组装。例如：将数据库连接池在后期组装时作为资源注入到系统中，这样使应用在开发过程中不会与资源绑定。
2. 简化应用的复杂度，使程序员开发中更多关注业务。例如：通过标注将资源在变量定义的时候注入进去，开发人员直接可以使用变量，而无须再通过代码获得。
3. 规范应用的开发过程，提升应用后期运行的稳定性。例如：通过注入的方式使用资源，而无须在开发期管理资源的生命周期以及创建与销毁，避免出现重复创建或者内存泄漏。

★ 哪些资源可以注入？
数据源、JMS目的地、环境变量、EJB、WebService、上下文资源、Managed Bean、Spring Bean、LocalString

★ 如何注入和使用资源？
 // Apusic系统日志，采用的是JDK 1.4的日志系统
 @Inject
 private java.util.logging.Logger logger;
 public void IndexBean() {
  logger.info("初始化IndexBean!");
 }

    // JavaServer Faces的相关资源
 // JSF的FacesContext
 @Inject
 private javax.faces.context.FacesContext fContext;
    // 获取应用的HttpRequest
    HttpServletRequest request=(HttpServletRequest)fContext.getCurrentInstance().getExternalContext().getRequest();
    // 获取应用的HttpResponse
    HttpServletResponse request=(HttpServletResponse)fContext.getCurrentInstance().getExternalContext().getResponse();
    // 获取应用的HttpSession
    HttpSession session=(HttpSession) fContext.getCurrentInstance().getExternalContext().getSession(true);
    // JSF的服务器实例
 @Inject
 private javax.faces.application.Application app;
 // JSF的导航句柄
 @Inject
 private javax.faces.application.NavigationHandler nHandler;
 // JSF的EL表达式工厂实例
 @Inject
 private javax.el.ExpressionFactory expFactory;
 // JSF的事件广播者实例
 @Inject
 private org.operamasks.faces.event.EventBroadcaster event;
 // 相同生命周期的ManagedBean，参考CRUD例子
 @Inject
 private IndexBean indexBean;

 // JNDI资源注入
 // 数据库连接池资源注入
 @Resource(mappedName = "jdbc/CRUD")
 private javax.sql.DataSource CRUD;
   Connection con = CRUD.getConnection();
 // 消息工厂资源注入
 @Resource(mappedName="jms/ConnectionFactory")
 private javax.jms.ConnectionFactory connFactory;
 // 消息主题资源注入
 @Resource(mappedName="testTopic")
 private javax.jms.Topic topic;
 // 消息队列资源注入
 @Resource(mappedName="testQueue")
 private javax.jms.Queue queue;
 // 事务服务资源注入，一个线程只提供一个事务服务，因此不需要提供名称直接可以注入
 @Resource
 private javax.transaction.UserTransaction tx;
 
 // EJB资源注入
 @EJB(name="com.apusic.examples.crud.second.service.PersonService")
 IPersonService personService;
 
 // 资源文件的注入，注意：只能注入前缀为LocalStrings的文件组
 @LocalString
 private Map<String, String> messages;
 messages.get("WindowBean.email.required");
 
    // 配置文件注入上下文资源
    在faces-config.xml中在需要注入的bean中加入managed-property属性和值
 <managed-bean>
  <managed-bean-name>windowBean</managed-bean-name>
  <managed-bean-class>
   com.apusic.examples.crud.second.bean.WindowBean
  </managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
  <managed-property>
   <property-name>injectName</property-name>
   <property-class>java.lang.String</property-class>
   <value>Operamasks</value>
  </managed-property>
 </managed-bean>
 在WindowBean.java中直接定义
 private String injectName;
 public void setInjectName(String injectName) { // 通过这个函数提供资源注入
  this.injectName = injectName;
 }
★ 参考资料
http://www.matrix.org.cn/resource/article/2006-04-05/Dependency+Injection_44321.html

★ 备注
本文现在只介绍了基础资源注入知识，随着作者本人对资源注入的理解，将会继续补充与完善。

术语：
Apusic：提供了完整的J2EE支持的商用服务器；
Spring：开源框架，是其他各种框架的粘合剂；
Oracle：著名的商业关系数据库系统；
MySQL：著名的开源关系数据库系统；
%APUSIC_HOME%：Apusic安装目录；
%JAVA_HOME%：JDK安装目录。

准备：
在http://java.sun.com下载JDK V1.5以上的版本并安装，确认JAVA_HOME正确指向装好的JDK目录；
在http://www.apusic.com下载Apusic V5.1以上的版本并安装；
在http://www.springframework.org/download上下载spring-framework-2.0.6-with-dependencies.zip（不过很遗憾，最近国内用户好像无法从sourceforge.net上下载东西，大家通过Google找找其他镜像网站吧）并解压缩到%APUSIC_HOME%/temp目录下；
在http://downloads.mysql.com/archives.php上下载MySQL Database V5.1并安装，下载MySQL Connector/J 3.1.14并解压缩到%APUSIC_HOME%/temp目录下。

过程：
1. 执行%APUSIC_HOME%/domains/mydomain/bin/startapusic.cmd，访问主页：http://localhost:6888/，确认Apusic已经成功安装，在窗口模式下按Ctrl+C停止服务器（记住因为是批处理还需要按Y确认）；
2. 安装MySQL数据库服务器，然后执行MySQL Query Browser，确认数据库正确安装、启动并可以连接使用；
3. 在%APUSIC_HOME%/temp/samples/imagedb/db目录下找到mysql-schema.txt文件，将这个文件中的脚本放到MySQL Query Browser中执行，创建新表imagedb；
4. 在%APUSIC_HOME%/temp/samples/imagedb/war/WEB-INF目录下找到jdbc.properties文件，打开并修改与JDBC相关的配置文件(注意配置正确的数据库名和用户名／)；
 jdbc.driverClassName=com.mysql.jdbc.Driver
 jdbc.url=jdbc:mysql://localhost:3306/mysql
 jdbc.username=root
 jdbc.password=password
 imageDatabase.lobHandler=defaultLobHandler
5. 在%APUSIC_HOME%/temp/mysql-connector-java-3.1.14目录下找到mysql-connector-java-3.1.14-bin.jar文件，拷贝到%APUSIC_HOME%/domains/mydomain/lib目录下，为应用提供支持JDBC的访问数据库的JAR包；
6. 找到samples/imagedb目录，执行warfile.bat生成dist/imagedb.war文件，将imagedb.war文件拷贝到%APUSIC_HOME%/domains/mydomain/applications/目录下，重新启动Apusic，稍等一会待Apusic自动部署，部署成功；
7. 有了前面的准备工作，访问http://localhost:6888/imagedb/，一切成功。

备注：
1. 由于Apusic的ClassLoader需要将Spring框架载入，所以第一次启动时有点慢，请稍等一下。

术语：
Apusic：提供了完整的J2EE支持的商用服务器；
Spring：开源框架，是其他各种框架的粘合剂；
%APUSIC_HOME%：Apusic安装目录；
%JAVA_HOME%：JDK安装目录。

准备：
在http://java.sun.com下载JDK V1.5以上的版本并安装，确认JAVA_HOME正确指向装好的JDK目录；
在http://www.apusic.com下载Apusic V5.1以上的版本并安装；
在http://www.springframework.org/download上下载spring-framework-2.0.6-with-dependencies.zip（不过很遗憾，最近国内用户好像无法从sourceforge.net上下载东西，大家通过Google找找其他镜像网站吧）。

过程：
1. 执行%APUSIC_HOME%/domains/mydomain/bin/startapusic.cmd，访问主页：http://localhost:6888/，确认Apusic已经成功安装，在窗口模式下按Ctrl+C停止服务器（记住因为是批处理还需要按Y确认）；
2. 解压缩spring的文件到%APUSIC_HOME%/temp目录下，然后找到samples/countries目录，执行warfile.bat生成dist/countries.war文件，将countries.war文件拷贝到%APUSIC_HOME%/domains/mydomain/applications/目录下，重新启动Apusic，稍等一会待Apusic自动部署，部署成功访问http://localhost:6888/countries/，一切成功。
3. “没有什么路途是一帆风顺的”。当点页面上Config时，系统报错:java.lang.NullPointerException，org.springframework.samples.countries.DefaultCountryService.getFilteredCountries(DefaultCountryService.java:59)读源代码，原来系统的的国家属性只支持EN、FR和DE，现在打开“工具→Internet选项→语言”，添加“英语[en]”，再访问现在好了。

备注：
1. 由于Apusic的ClassLoader需要将Spring框架载入，所以第一次启动时有点慢，请稍等一下。

术语：
Struts：使用最为广泛的MVC框架。
Apusic：完全支持J2EE规范的商业应用服务器产品，最新版本V5.1可以提供对Java EE 5.0的完整实现。
%APUSIC_HOME%：Apusic安装目录

准备：
在http://archive.apache.org/dist/struts/binaries/struts-2.0.9-all.zip下载Struts V2.0.9的压缩包；
在http://archive.apache.org/dist/struts/binaries/struts-1.3.9-all.zip下载Struts V1.3.9的压缩包；
在http://java.sun.com/javase/downloads/index_jdk5.jsp下载JDK V1.5以上的版本并安装，确认JAVA_HOME正确指向装好的JDK目录；
在http://www.apusic.com/dist/apusicAS/v5.1/Apusic-5.1-OS-Independent.zip下载Apusic V5.1并解压；

Struts 2.x的部署过程：
1. 执行%APUSIC_HOME%/domains/mydomain/bin/startapusic.cmd，访问主页：http://localhost:6888/，确认Apusic已经成功安装；
2. 打开Struts V2.0.9的例子包，如果下载的是完整的Struts则在APP目录下；
3. 将struts2-blank-2.0.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts2-blank-2.0.9/访问一下，已经OK了。（好棒好简单。。。）
4. 将struts2-mailreader-2.0.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用
http://localhost:6888/struts2-mailreader-2.0.9/访问一下，已经OK了。（好棒好简单。。。）
5. 将struts2-showcase-2.0.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），不会那么没创意吧，又成功啦？自动部署完成，但是后台部署过程报错：
javax.servlet.ServletException: java.lang.IllegalStateException: Application was not properly initialized at startup, co
uld not find Factory: javax.faces.context.FacesContextFactory
这个错误是跟JSF有关的，原因现在搞不懂，不管他。先用http://localhost:6888/struts2-showcase-2.0.9/访问一下，好像没啥问题，进入主页一看例子提供了不少使用Struts的方法很值得学习，一一点过都很正常，而且还看到了JavaServer Faces，看样子Struts也在追赶潮流啦，点进去→再点List available Employees （http://localhost:6888/struts2-showcase-2.0.9/jsf/employee/list.action）出错啦，去Apusic的后台看看。又有新的错误信息：
Unable to initialize jsf interceptors probably due missing JSF implementation libraries，说我没有提供实现库。不可能呀，Apusic已经提供了Operamasks的JSF实现呀，不过Struts肯定不会用Operamasks的，那是不是自带的JSF实现呢？打开WAR包进入WEB-INF/lib发现里面还有MyFaces的实现库。估计是两种JSF实现冲突了。看样子要动点脑筋了！
整个简单的办法，把Apusic的所有与JSF相关的JAR包都删除掉，让Apusic V5.1变成一个纯的WEB容器。与JSF相关的有三个文件：
● jsf-api.jar：%APUSIC_HOME%/common
● Operamasks-impl.jar：%APUSIC_HOME%/lib
● Operamasks-third-party.jar：%APUSIC_HOME%/lib/ext
停止应用服务器，把他们都删除掉，再重新启动后访问struts2-showcase-2.0.9.war的JSF例子，这下就行了。
7. 将struts2-portlet-2.0.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署也报错：
Could not load class org.apache.struts2.portlet.interceptor.PortletPreferencesInterceptor.看样子还需要加入Portal服务器才行，在网上搜了一下没有部署介绍，而且也说需要先部署好PortalServer支持，难度不小。尝试下了Pluto但是部署了没起作用，后来下了2.1.2版本，结果那个例子更成问题，只好先放弃。等到熟悉了Portal再回头补课。

Struts 1.x的部署过程：
1. 执行%APUSIC_HOME%/domains/mydomain/bin/startapusic.cmd，访问主页：http://localhost:6888/，确认Apusic已经成功安装；
2. 打开Struts V1.3.9的例子包，如果下载的是完整的Struts则在apps目录下；
3. 将struts-blank-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-blank-1.3.9/访问一下，已经OK了；
4. 将struts-cookbook-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-cookbook-1.3.9/访问一下，已经OK了，访问里面的内容也可以正确执行；
5. 将struts-el-example-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-el-example-1.3.9/访问一下，已经OK了，访问里面的内容也可以正确执行；
6. 将struts-examples-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-examples-1.3.9/访问一下，已经OK了，访问里面的内容也可以正确执行（这个例子其实是上面三个例子的集成）；
7. 下面的两个例子都与myfaces有关，为了防止JSF实现冲突，先停止服务器，将Apusic的JSF实现删除（参考Struts 2.x中的6）；
8. 将struts-faces-example1-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-faces-example1-1.3.9/访问一下，已经OK了，访问里面的内容也可以正确执行；
9. 将struts-faces-example2-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-faces-example2-1.3.9/访问一下，已经OK了，访问里面的内容也可以正确执行；
10. 将struts-mailreader-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-mailreader-1.3.9/访问一下，已经OK了(注意：我下载的这个例子图片无法正常显示，打开应用发现根本没有把图片文件打入WAR包)，访问里面的内容也可以正确执行；
11. 将struts-scripting-mailreader-1.3.9.war拖入%APUSIC_HOME%/domains/mydomain/applications目录下（稍等一下），自动部署完成，用http://localhost:6888/struts-scripting-mailreader-1.3.9/访问一下，已经OK了(注意：我下载的这个例子图片无法正常显示，打开应用发现根本没有把图片文件打入WAR包)，访问里面的内容也可以正确执行。

备注：
1. 删除了Operamasks的实现包，如果别的应用仍然想用Operamasks，最好的办法就是直接把这三个包加入到应用的WEB-INF/lib下面就可以了。

过程：
1. 执行%TOMCAT_HOME%/bin/startup.bat，访问例子Examples：http://localhost:8080/jsp，确认Tomcat和Examples成功安装，在窗口模式下按Ctrl+C停止服务器；
2. 执行%APUSIC_HOME%/domains/mydomain/bin/startapusic.cmd，访问主页：http://localhost:6888/，确认Apusic已经成功安装，在窗口模式下按Ctrl+C停止服务器（记住因为是批处理还需要按Y确认）；
3. 找到%TOMCAT_HOME%/webapps/examples目录，将examples目录拷贝到%APUSIC_HOME%/domains/mydomain/applications/下，重新启动Apusic，稍等一会待Apusic自动部署，应用报错：java.lang.NoClassDefFoundError: org/apache/catalina/CometProcessor，这个错误是因为应用中使用了Tomcat内核的API（非J2EE规范），虽然编写这样的应用违背J2EE规范（JBoss和Resin也这样做过），但是既然应用已经这样使用必须想办法支持。
4. 一种方法是找出应用代码中的部分进行修改，很遗憾我没有找到；另一种就是把那个需要引用的类所在的catalina.jar文件拷贝到%APUSIC_HOME%/domains/mydomain/lib目录下，先停止Apusic应用服务器，然后重新启动。
5. 稍等一下，Apusic自动部署了examples应用，现在访问例子：http://localhost:6888/examples/
6. 哇，成功了。就这么简单就可以完成Tomcat应用到Apusic应用的移植。
总结：Apusic是个符合J2EE规范的应用服务器，在Tomcat上开发的应用都可以非常简单的移植到Apusic上。并且Apusic同样支持WAR包（WEB模块）的直接部署。

备注：
0. 访问http://localhost:6888/examples/jsp/jsp2/el/basic-arithmetic.jsp出错了，为什么？
 因为J2EE规范中除0是必须抛出错误，而Tomcat则没有遵守规范操作，请开发者注意。
 当然，完美主义者还是希望看到正常显示的页面，那么请把这个文件中的3/0替换成3/4就可以了。
1. 打开examples应用的lib目录，会发现里面还有两个jar文件：jstl.jar和standard.jar，这是支持Standard Library用的，其实Apusic已经自带无须他们，现在停止Apusic服务器，再删除这两个JAR包，然后重新启动Apusic服务器，应用果然可以正常运行；
2. 移植时把catalina.jar全部拷过来了，里面包含了Tomcat对WEB容器的部分实现，那么肯定会疑虑系统到底在调用谁的实现呢？为了确认我们可以将Apusic服务器停止，用WINRAR打开catalina.jar文件，把里面与Comet无关的class全部删除，再重新启动Apusic服务器，应用仍然可以正常运行，现在没有疑虑了；
3. 为什么每次都需要停止服务器才能操作lib里面的JAR文件呢，难道Apusic不支持热部署？
Apusic当然支持热部署，将Examples直接拷贝到applications目录下其实就是热部署，你甚至可以在Apusic启动完成后再执行拷贝也可以。但是应用一旦被加载进应用服务器后，所有的jar文件全部会被锁定，以便保证应用的完整性，所以修改lib下的jar文件必须将应用服务器重新启动。
4. 建议不要部署压缩文件，而是部署将应用展开后的目录，因为对于压缩文件应用服务器启动时还需要一个解压过程，降低启动速度消耗系统资源；
5. 如何在Apusic上给WEB模块配置上下文呢？
 现在打开%APUSIC_HOME%/domains/mydomain/config/server.xml可以看到新部署的examples的说明： 
<application name="examples" base="applications/examples" start="auto"/>，因为examples不是标准的J2EE应用，导致WEB模块中没有指定上下文，因此可以使用name来指定上下文，比如：
<application name="Apusic-examples" base="applications/examples" start="auto"/>就把应用的上下文换成apusic-examples了，访问自然也变成了http://localhost:6888/apusic-examples，简单吧！

为了满足应用需要，特别对以下环境进行了调优。系统基本配置如下：
HP-UX V11.11　2CPU 4G
HP JDK V1.5
Apusic V5.0
SQL Server 2005

系统硬件条件已经确定，系统资源调用变化最频繁的就是应用服务器，因此应用服务器所在的操作系统、Java虚拟机(Java Virtual Machine, JVM)和Apusic AS都需要调优。而应用服务器对数据库的数据库连接池大小也必定会影响数据库服务器的相关压力，因此最后再根据稳定后的应用服务器调整数据库服务器配置。

1. 先调整JVM。这个先根据JVM所在的应用服务器物理内存的大小和JDK所支持的大小决定，建议是将空闲内存的70%～80%分配给JVM使用。下面是Java启动时用的配置参数：
-server -Xms1024m -Xmx1024m -Xmn?m -XX:MaxPermSize=256m -XX:NewSize=128m -XX:MaxNewSize=128m -XX:SurvivorRatio=8 -Xincgc、

注：1. 不同JDK在不同OS下所能使用的内存大小是不同
 2. Heap的大小和分配现在设置的是经验值，是否调整最终还需要分析应用来定，一般经验值已经满足需要。
 3. GC的机制对系统稳定也比较重要，尽可能参考JDK提供的最新GC参数。
 4. 使用server版的JVM一般都会对应用系统提升带来帮助。

2. 再调整Apusic应用服务器。因为并发压力大，也意味着系统对CPU和内存的资源消耗都会比较大，为保证应用服务器的稳定修改apusic.conf的配置如下（只保留了修改的部分）：
2.1. 线程池调整
 为了平衡用户访问速度与并发支持的关系，必须调整Apusic的线程池。调整前依据以下原则：
 ● 每CPU50用户的原则（线程池的设置可参考《Apusic AS V5.1线程池配置和调优》）。
 ● HTTPHandler是MuxHandler的三倍。
<SERVICE
    CLASS="com.apusic.util.ThreadPoolService"
    NAME="Apusic:service=ThreadPool,name=MuxHandler"
    >
    <ATTRIBUTE NAME="MaxThreads" VALUE="100"/>
    <ATTRIBUTE NAME="MaxSpareThreads" VALUE="30"/>
    <ATTRIBUTE NAME="MinSpareThreads" VALUE="30"/>
</SERVICE>

<SERVICE
    CLASS="com.apusic.util.ThreadPoolService"
    NAME="Apusic:service=ThreadPool,name=HTTPHandler"
    >
    <ATTRIBUTE NAME="MaxThreads" VALUE="300"/>
    <ATTRIBUTE NAME="MaxSpareThreads" VALUE="100"/>
    <ATTRIBUTE NAME="MinSpareThreads" VALUE="100"/>
</SERVICE>

2.2. Mux（多路复用服务）调优。多路复用是将客户端的服务申请分发给相应的服务，如：HTTP服务、JMS服务等等。因此该服务对资源占用时间较短，不需要分配太多线程，只需要关注他的接收能力和申请排队，保证申请不会丢失。
<SERVICE
    CLASS="com.apusic.net.Muxer"
    >
    <ATTRIBUTE NAME="NumberSelectors" VALUE="2"/>
 <!-- 系统CPU核数，多个CPU使用多个Selectors可以加快并发处理能力 -->
    <ATTRIBUTE NAME="Port" VALUE="80"/>
 <!-- 默认的服务端口 -->
    <ATTRIBUTE NAME="Backlog" VALUE="50"/>
 <!-- TCP/IP的队列大小，如果有大量客户端连接超时，而服务器又没有足够的CPU压力，可以调大这个值 -->
</SERVICE>

2.3. WEB服务调优。
<SERVICE
    CLASS="com.apusic.web.WebService"
    >
    <ATTRIBUTE NAME="NumberSelectors" VALUE="2"/>
 <!-- 系统CPU核数，多个CPU使用多个Selectors可以加快并发处理能力 -->
    <ATTRIBUTE NAME="MaxKeepAliveConnections" VALUE="300"/>
 <!-- 最大保持KeepAlive的连接数，与HTTPHandler保持一致 -->
    <ATTRIBUTE NAME="MaxKeepAliveRequests" VALUE="600"/>
 <!-- 最大保持KeepAlive的请求数，设HTTPHandler×2，大约一个连接支持两次请求，如果服务器硬件条件允许可以再开大些 -->
    <ATTRIBUTE NAME="WaitingClientTimeout" VALUE="15"/>
    <ATTRIBUTE NAME="MaxWaitingClients" VALUE="200"/>
 <!-- 等待队列满了后，将客户端请求抛弃的等待时间。如果关注系统反应的及时性，就把这个值调小，还可以把请求队列MaxWaitingClients调小；如果关注系统服务的有效性则要调大。-->
    <ATTRIBUTE NAME="KeepAlive" VALUE="True"/>
 <!-- 默认打开KeepAlive，了解这个参数配置需要参看HTTP 1.1协议 -->
    <ATTRIBUTE NAME="ServletReloadCheckInterval" VALUE="-1"/>
 <!-- 设为-1，意思就是不检查，因为这个功能是为开发阶段提供热部署的 -->
    <ATTRIBUTE NAME="KeepAliveTimeout" VALUE="15"/>
 <!-- 服务器关闭客户端连接前等待下一次请求的时间，如果系统压力较大可以将这个值设小，以便应对更多的请求。 -->
</SERVICE>

2.3. Session服务
基本上采用默认值就可以了，如果需要配置集群才需要调整Session里面某些配置选项，具体可以参考Apusic集群配置。

2.4. 数据库连接池服务
<datasources>
  <datasource name="test"
     jndi-name="jdbc/test"
     driver-class="net.sourceforge.jtds.jdbc.Driver"
     url="Jdbc:jtds:sqlserver://192.168.0.1:1433/test"
     min-spare-connections="50"
     max-spare-connections="50"
     max-connections="150"
     initial-connections="50"
  >
    <property name="user" value="sa"/>
    <property name="test-before-reused" value="false"/>
    <property name="password" value="test"/>
    <property name="stmt-cache-size" value="50"/>
    <property name="pre-fetch-size" value="50"/>
  </datasource>
</datasources>
min-spare-connections、max-spare-connections：在池中保留的空闲数据库连接数；
initial-connections：初始化的空闲数据库连接数；
三个值相同，保证在初始化时就有足够的数据库连接使用。
数据库连接数×2＝HTTP线程池数目
注：max-connections在现实中被调小。因为数据库服务器无法处理更多响应，因此原则是先保证拥有数据库连接的线程能够有效响应。

3. 调整HP-UX操作系统。
3.1. 首先调整核心资源，使用ulimit -a查看核心参数，特别关注file和memory两部分的使用，有些时候操作系统限制了进程打开文件数和内存使用数，无法有效利用硬件资源也会限制应用服务器性能的发挥。

3.2. 因为应用系统受到攻击，致使出现大量的CLOSE_WAIT、FIN_WAIT_2这样状态的连接，消耗大量系统资源。因此使用ndd进行网络参数配置，先用：ndd /dev/tcp，然后输入?，可以得到所有网络参数情况。使用：ndd -get /dev/tcp 参数名称，可以获得原参数的值。使用：ndd -set /dev/tcp 参数名称 参数值，可以设置新参数的值。例如：获得初始值：ndd -get /dev/tcp tcp_time_wait_interval，设置新值：ndd -set /dev/tcp tcp_time_wait_interval 30000，30000是毫秒单位=30秒。不能设置为0，0似乎是无限长的意思。需要关注的参数如下：
#与TIME_WAIT相关的参数，当系统出现大量此状态的连接时可以调小这个值
tcp_time_wait_interval   30000
tcp_tw_cleanup_interval  60000
#与FIN_WAIT相关的参数
tcp_fin_wait_2_timeout   1000
#与KeepAlive相关的参数，因为应用服务器不负责KeepAlive连接的管理，因此这里由操作系统负责
tcp_keepalive_interval   120000
tcp_keepalive_detached_interval 120000
tcp_keepalives_kill   1
tcp_ip_abort_interval   600000
#与TCP连接数相关的参数
tcp_conn_request_max   4096

注：使用ndd重新启动后就无效了。可以修改/etc/rc.config.d/nddconf就可以在机器重新启动时有效。

4. 调整SQL Server数据库的参数。这个是因为数据库压力较大，才关注到这个部分调优。
4.1. 内存调整。因为SQL Server内存管理默认无限大，结果把系统资源全部耗尽，因此将服务器内存按照70～80%原则分配给SQL Server使用。
4.2. 处理器设置。主要是选择提升SQL Server的优先级和使用Windows纤程，保证SQL Server在操作系统中的执行速度。
4.3. 连接设置。控制最大并发连接数，比数据库连接池所设的连接数稍大就可以了，防止过多连接导致系统切换线程带来的资源消耗。同时合理设置查询的超时时间，保证资源不会被某个访问占用。
4.4. 活动监视器。通过活动监视器查看系统中的活动进程，以及执行的SQL语句，并且在系统压力较大时观察是否有资源被锁。
 不过这些其实都只是帮助系统更好的运行，实际上SQL Server资源消耗问题的解决仍然领先应用的调整，应用发现某些表关联有问题，重新调整后CPU压力立刻降低。

 以上是整个调优的过程记录。

2. 在apusic.conf文件中自定义一个线程池Test，然后可以在自己的代码中使用Apusic AS提供的池管理技术，当然如果没有使用这个池系统也仍然可以正常运行，因为这只是个池服务，只是没有线程加入到池中而已。
<SERVICE
    CLASS="com.apusic.util.ThreadPoolService"
    NAME="Apusic:service=ThreadPool,name=Test"
    >
    <ATTRIBUTE NAME="MaxThreads" VALUE="150"/>
    <ATTRIBUTE NAME="Priority" VALUE="5"/>
    <ATTRIBUTE NAME="ServicePriority" VALUE="H"/>
    <ATTRIBUTE NAME="IdleTimeout" VALUE="300"/>
    <ATTRIBUTE NAME="MaxSpareThreads" VALUE="30"/>
    <ATTRIBUTE NAME="MinSpareThreads" VALUE="5"/>
    <ATTRIBUTE NAME="MaxQueueSize" VALUE="500"/>
</SERVICE>

3. 只提供default池，其他池都注释掉，系统依然能够正常运行，也是因为池与服务之间不是紧耦合，没有的相关的池，所有的线程统一使用default池，如果有自己的池就通过自定义池处理。
注意：如果有了自定义池，池中线程数达到最大值后，系统不会使用defalut池来处理的，从而充分保证相应服务池的控制。
例如：定义了HTTPHandler池，当HTTPHandler线程达到最大值后，其他只能在Queue中排队，如果Queue也满了，则其他请求将会被拒绝。

Apusic AS自己使用了五种池：
default：Apusic AS系统默认的线程池
MuxHandler：多路复用的线程池，主要是将请求向不同的服务，如：HTTP、JMS、ORB等服务上分配
HTTPHandler：HTTP服务的线程池
JMSHandler：JMS服务的线程池
ORBHandler：ORB服务的线程池
了解了线程池的基本概念，就可以知道在线程池配置中default池最为重要，其他池可以根据需要增加或者注释，所有线程池的配置参数都是相同的，具体的配置参数解释如下：
MaxThreads：线程池中能够运行的最大线程数，也就是提供服务的线程数，-1代表无限制
MinSpareThreads，MaxSpareThreads：线程池中最小／最大空闲的线程数，当线程数符合这个区间时无论空闲多久都不会被销毁
IdelTimeout：空闲线程超时的时间，超时后会如果运行的线程总数大于MaxSpareThreads则被销毁
Priority（1～10）：受Java线程优先级管理
ServicePriority：服务启动的优先级，五种（H > A > N > B > L）
MaxQueueSize：当所有线程都忙时，为无法获得线程的请求提供队列进行排队，Size代表队列长度，队列满时请求被抛弃

Apusic AS的线程池优化：
● 一般的WEB应用部署在Apusic上时，不会用到JMS和ORB服务，因此可以将这两个池注释掉，减少资源消耗。
● 如果应用现阶段使用人数不多，但是伴随着发展应用人数会不断增长，可以将MinSpareThreads调整为符合现阶段情况的值，将MaxSpareThreads调整为符合将来的值，这样系统无须再变动就可以有效支持很长一段时间；
● 如果应用一段时间内访问量变化不大，但是系统偶尔会遇到高峰访问，那么可以设置MinSpareThreads=MaxSpareThreads；
● MaxThreads的值依据CPU数量来定，参考值50×CPU核数，具体值还需要根据应用执行过程中对CPU的压力决定。
● 关于Apusic AS V5.1服务的配置，下篇文章会单独介绍。

附一、
Full thread dump Java HotSpot(TM) Client VM (1.5.0_14-b03 mixed mode, sharing):

"AutoDeployer" prio=6 tid=0x030f2970 nid=0x9e0 in Object.wait() [0x03cef000..0x03cefc6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x23460458> (a com.apusic.deploy.runtime.AutoDeployer)
        at com.apusic.deploy.runtime.AutoDeployer.run(Unknown Source)
        - locked <0x23460458> (a com.apusic.deploy.runtime.AutoDeployer)
        at java.lang.Thread.run(Thread.java:595)

"Thread-4" prio=6 tid=0x031ca7f0 nid=0x21c in Object.wait() [0x0349f000..0x0349fd6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2321c188> (a com.sun.corba.se.impl.javax.rmi.CORBA.KeepAlive)
        at java.lang.Object.wait(Object.java:474)
        at com.sun.corba.se.impl.javax.rmi.CORBA.KeepAlive.run(Util.java:736)
        - locked <0x2321c188> (a com.sun.corba.se.impl.javax.rmi.CORBA.KeepAlive)

"HTTPSessionSwapper" prio=6 tid=0x031d8168 nid=0xb98 in Object.wait() [0x0345f000..0x0345fa6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2318ba58> (a java.lang.Object)
        at com.apusic.web.session.SessionManager$HouseKeeper.run(Unknown Source)
        - locked <0x2318ba58> (a java.lang.Object)

"HttpLogger" prio=2 tid=0x031be630 nid=0xfe8 in Object.wait() [0x0341f000..0x0341f9ec]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2317d2b8> (a com.apusic.web.http.HttpLogger)
        at java.lang.Object.wait(Object.java:474)
        at com.apusic.web.http.HttpLogger.getNextRecord(Unknown Source)
        - locked <0x2317d2b8> (a com.apusic.web.http.HttpLogger)
        at com.apusic.web.http.HttpLogger.run(Unknown Source)

"MuxListener" prio=6 tid=0x031a8be8 nid=0x7dc runnable [0x033df000..0x033dfaec]
        at java.net.PlainSocketImpl.socketAccept(Native Method)
        at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:384)
        - locked <0x23177890> (a java.net.SocksSocketImpl)
        at java.net.ServerSocket.implAccept(ServerSocket.java:450)
        at java.net.ServerSocket.accept(ServerSocket.java:421)
        at com.apusic.net.BlockingListenerThread.run(Unknown Source)

"Timer-0" prio=6 tid=0x031c3b08 nid=0xc98 in Object.wait() [0x0339f000..0x0339fb6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x23133120> (a java.util.TaskQueue)
        at java.util.TimerThread.mainLoop(Timer.java:509)
        - locked <0x23133120> (a java.util.TaskQueue)
        at java.util.TimerThread.run(Timer.java:462)

"LogManager" prio=2 tid=0x02e2c680 nid=0xb20 waiting on condition [0x0335f000..0x0335fbec]
        at sun.misc.Unsafe.park(Native Method)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:118)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:
841)
        at com.apusic.util.concurrent.LinkedBlockingQueue.take(Unknown Source)
        at com.apusic.logging.manager.ServerLogManager$PushThread.dequeue(Unknown Source)
        at com.apusic.logging.manager.ServerLogManager$PushThread.run(Unknown Source)

"Low Memory Detector" daemon prio=6 tid=0x00a83bf0 nid=0xa6c runnable [0x00000000..0x00000000]

"CompilerThread0" daemon prio=10 tid=0x00a537b8 nid=0xdc4 waiting on condition [0x00000000..0x02c2f6cc]

"Signal Dispatcher" daemon prio=10 tid=0x00a95a58 nid=0xeb0 waiting on condition [0x00000000..0x00000000]

"Finalizer" daemon prio=8 tid=0x00a50870 nid=0xbd0 in Object.wait() [0x02baf000..0x02bafa6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x230d25c8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:120)
        - locked <0x230d25c8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:136)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)

"Reference Handler" daemon prio=10 tid=0x00a4f3e8 nid=0xf94 in Object.wait() [0x02b6f000..0x02b6faec]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x230d2650> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:474)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)
        - locked <0x230d2650> (a java.lang.ref.Reference$Lock)

"main" prio=6 tid=0x00038c00 nid=0x718 in Object.wait() [0x0007f000..0x0007fc3c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x230e0ed8> (a com.apusic.server.J2EEServer)
        at java.lang.Object.wait(Object.java:474)
        at com.apusic.server.J2EEServer.startup(Unknown Source)
        - locked <0x230e0ed8> (a com.apusic.server.J2EEServer)
        at com.apusic.server.Main.main(Unknown Source)

"VM Thread" prio=10 tid=0x00a80190 nid=0x490 runnable

"VM Periodic Task Thread" prio=10 tid=0x00a8e780 nid=0xcec waiting on condition

附二、
Full thread dump Java HotSpot(TM) Client VM (1.5.0_14-b03 mixed mode, sharing):

"Running HTTPHandler-1" prio=6 tid=0x02febe58 nid=0xbd8 runnable [0x03d6f000..0x03d6fb6c]
        at java.net.SocketInputStream.socketRead0(Native Method)
        at java.net.SocketInputStream.read(SocketInputStream.java:129)
        at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
        at java.io.BufferedInputStream.read1(BufferedInputStream.java:256)
        at java.io.BufferedInputStream.read(BufferedInputStream.java:313)
        - locked <0x234dd378> (a java.io.BufferedInputStream)
        at com.apusic.web.http.tcp.TCP_BIOProtocol.readLine(Unknown Source)
        at com.apusic.web.http.tcp.TCP_BIOProtocol.readRequestLine(Unknown Source)
        at com.apusic.web.http.tcp.TCP_BIOProtocol.read(Unknown Source)
        at com.apusic.web.http.tcp.TCP_BIOConnection.getNextRequest(Unknown Source)
        at com.apusic.web.http.ConnectionHandler.processConnection(Unknown Source)
        at com.apusic.web.http.ConnectionHandler.run(Unknown Source)
        at com.apusic.util.ThreadPoolImpl$WorkerThread.run(Unknown Source)

"Idle MuxHandler-1" prio=6 tid=0x02cc0d90 nid=0x54c in Object.wait() [0x03d2f000..0x03d2fbec]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x23147df0> (a java.lang.Object)
        at com.apusic.util.ThreadPoolImpl.getWork(Unknown Source)
        - locked <0x23147df0> (a java.lang.Object)
        at com.apusic.util.ThreadPoolImpl$WorkerThread.run(Unknown Source)

"AutoDeployer" prio=6 tid=0x03146980 nid=0x7bc in Object.wait() [0x03cef000..0x03cefc6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2344f8c0> (a com.apusic.deploy.runtime.AutoDeployer)
        at com.apusic.deploy.runtime.AutoDeployer.run(Unknown Source)
        - locked <0x2344f8c0> (a com.apusic.deploy.runtime.AutoDeployer)
        at java.lang.Thread.run(Thread.java:595)

"Thread-4" prio=6 tid=0x031e3868 nid=0xdc8 in Object.wait() [0x0349f000..0x0349fd6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2321c188> (a com.sun.corba.se.impl.javax.rmi.CORBA.KeepAlive)
        at java.lang.Object.wait(Object.java:474)
        at com.sun.corba.se.impl.javax.rmi.CORBA.KeepAlive.run(Util.java:736)
        - locked <0x2321c188> (a com.sun.corba.se.impl.javax.rmi.CORBA.KeepAlive)

"HTTPSessionSwapper" prio=6 tid=0x031c1948 nid=0x9f4 in Object.wait() [0x0345f000..0x0345fa6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2318ba58> (a java.lang.Object)
        at com.apusic.web.session.SessionManager$HouseKeeper.run(Unknown Source)
        - locked <0x2318ba58> (a java.lang.Object)

"HttpLogger" prio=2 tid=0x031b8830 nid=0xb2c in Object.wait() [0x0341f000..0x0341f9ec]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x2317d2b8> (a com.apusic.web.http.HttpLogger)
        at java.lang.Object.wait(Object.java:474)
        at com.apusic.web.http.HttpLogger.getNextRecord(Unknown Source)
        - locked <0x2317d2b8> (a com.apusic.web.http.HttpLogger)
        at com.apusic.web.http.HttpLogger.run(Unknown Source)

"MuxListener" prio=6 tid=0x02e654a8 nid=0xa28 runnable [0x033df000..0x033dfaec]
        at java.net.PlainSocketImpl.socketAccept(Native Method)
        at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:384)
        - locked <0x23177890> (a java.net.SocksSocketImpl)
        at java.net.ServerSocket.implAccept(ServerSocket.java:450)
        at java.net.ServerSocket.accept(ServerSocket.java:421)
        at com.apusic.net.BlockingListenerThread.run(Unknown Source)

"Timer-0" prio=6 tid=0x02e65c08 nid=0xdf0 in Object.wait() [0x0339f000..0x0339fb6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x23133120> (a java.util.TaskQueue)
        at java.util.TimerThread.mainLoop(Timer.java:509)
        - locked <0x23133120> (a java.util.TaskQueue)
        at java.util.TimerThread.run(Timer.java:462)

"LogManager" prio=2 tid=0x02e2d488 nid=0xbfc waiting on condition [0x0335f000..0x0335fbec]
        at sun.misc.Unsafe.park(Native Method)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:118)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:1
841)
        at com.apusic.util.concurrent.LinkedBlockingQueue.take(Unknown Source)
        at com.apusic.logging.manager.ServerLogManager$PushThread.dequeue(Unknown Source)
        at com.apusic.logging.manager.ServerLogManager$PushThread.run(Unknown Source)

"Low Memory Detector" daemon prio=6 tid=0x00a83c78 nid=0xc5c runnable [0x00000000..0x00000000]

"CompilerThread0" daemon prio=10 tid=0x00a53910 nid=0x780 waiting on condition [0x00000000..0x02c2f6cc]

"Signal Dispatcher" daemon prio=10 tid=0x00a95ae8 nid=0xc8c waiting on condition [0x00000000..0x00000000]

"Finalizer" daemon prio=8 tid=0x00a50870 nid=0xd10 in Object.wait() [0x02baf000..0x02bafa6c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x230d25c8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:120)
        - locked <0x230d25c8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:136)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)

"Reference Handler" daemon prio=10 tid=0x00a4f3e8 nid=0x1d0 in Object.wait() [0x02b6f000..0x02b6faec]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x230d2650> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:474)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)
        - locked <0x230d2650> (a java.lang.ref.Reference$Lock)

"main" prio=6 tid=0x00038c00 nid=0x7fc in Object.wait() [0x0007f000..0x0007fc3c]
        at java.lang.Object.wait(Native Method)
        - waiting on <0x230e0ed8> (a com.apusic.server.J2EEServer)
        at java.lang.Object.wait(Object.java:474)
        at com.apusic.server.J2EEServer.startup(Unknown Source)
        - locked <0x230e0ed8> (a com.apusic.server.J2EEServer)
        at com.apusic.server.Main.main(Unknown Source)

"VM Thread" prio=10 tid=0x00a80190 nid=0xab4 runnable

"VM Periodic Task Thread" prio=10 tid=0x00a8e808 nid=0x684 waiting on condition

参考：
http://infocenter.apusic.com/help/index.jsp?topic=/com.apusic.studio.doc.server/output/eclipse/threadpool.html