2009年12月5日
#
Sun推出的专业认证包括下列三种：
◆JAVA认证考试
对于JAVA程序设计员，Sun推出两项认证:
Sun Certified JAVA Programmer(SCJP)
Sun Certified JAVA Developer(SCJD)
Java程序员的认证Sun Certified JAVA Programmer(SCJP)课程：SL-275JAVA语言编程,考试号为310-025.
java开发员认证Sun Certified JAVA Deverloper（SCJD），认证考试以Sun指定的javaSL-285为教材，机考部分的考试号为310-027。
SCJP测验JAVA程序设计概念及能力，内容偏重于JAVA语法及JDK的内容；SCJD则进一步测试用JAVA开发应用程序的能力，考试者必须先完成一个程序的设计方案，再回答与此方案相关的一些问题。
◆Solaris系统管理认证考试
对Solaris/SunOS系统管理员，Sun推出Certified Solaris Administrator(CSA)。CSA分别为两个等级(PartI和PartII)，测试对Solaris系统管理的了解程度。
◆Solaris网络管理认证考试
为了测试使用者对于Solaris网络管理能力，Sun推出Certified Network Administrator(CNA)。内容包括基本网络概念、RoutingandSubnet、Security、Performance、DNS、NIS+等。
SunJava认证是业界唯一经Sun授权Java认证培训。Sun认证Java开发员考试内容包括完整的Java应用程序开发，涉及数据库、图形用户界面、网络通信、平台移植等各方面内容，要求学员已通过Java程序员认证。学习结束后，可参加全球连网考试。考试合格则由Sun公司颁发国际通用的Java开发员证书。
Java语言在1995年发布以来，因其具有简单性、跨平台、面向对象等特点，受到程序员们的欢迎，经过这几年的迅速发展，现在已经成为和C++语言并列的主流开发语言。Java语言的广泛使用，使得越来越多的人加入到Java语言的学习和应用中来。
在这些人当中，许多人选择了经过Sun公司授权的Sun教育中心（ASEC）来学习，因为和一些非授权的中心相比，只有ASEC受到Sun组合机床公司的关注和支持，他们可以提供最新的培训材料和Sun需要的精深技术资源。学员在那里可以学习到最新的Java技术，更顺利地通过SunJava的认证考试。
了解SunJava认证课程
Java不仅仅是一种编程语言，同时它也是一个开发和运行的平台，有自己完整的体系结构。SunJava认证课程从中选择了最具有代表性的一些方面。
SCJP（Sun Certified Java Programmer）可以说是各种Java认证的基础，其对应的最主要的学习课程是一门Java的基础课程，也就是Java Programming Language（SL-275），这也是国内的SCJP培训的标准课程。而SCJD（Sun Certified Java Developer）则可以看做是高级的Java技术培训认证，其要求和难度都要高于SCJP，而且，如果你计划获得SCJD认证，则要先获得SCJP认证资格。SCEA（Sun Certified Enterprise Architect for J2EE Technology）认证的难度也不小，其学习课程主要有两个：00-226O bject-Oriented Analysisand Design以及SL-425 Architectingand Designing J2EE Applications。SCWD（Sun Certified WebComponent Developer for Java2 Platform Enterprise Edition）是Sun新推出的Java认证考试，主要面向使用JavaServlet以及JSP技术开发Web应用程序的相关技术认证。
如何获取Java认证
首先，你需要有充分的心理准备，因为SunJava认证考试非常严谨，需要你具备充足的实践经验才可能通过。
数据库连接池概述：
数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接干洗设备数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：
1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；
2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。
3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。
目前常用的连接池有：C3P0、DBCP、Proxool
网上的评价是：
C3P0比较耗费资源，效率方面可能要低一点。
DBCP在实践中存在BUG，在某些种情会产生很多空连接不能释放，Hibernate3.0已经放弃了对其的支持。
Proxool的负面评价较少，现在比较推荐它，而且它还提供即时监控连接池状态的功能，便于发现连接泄漏的情况。
配置如下：
1、在spring配置文件中，一般在applicationContext.xml中
<bean id="DataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource" destroy-method="shutdown">
<property name="driver">
<value>oracle.jdbc.driver.OracleDriver</value>
</property>
<property name="driverUrl">
<value>jdbc:oracle:thin:xxxx/xxxx@192.168.0.XX:1521:server</value>
</property>
<property name="user">
<value>xxxx</value>
</property>
<property name="password">
<value>xxxx</value>
</property>
<property name="alias">
<value>server</value>
</property>
<property name="houseKeepingSleepTime">
<value>30000</value>
</property>
<property name="houseKeepingTestSql">
<value>select 1 from dual</value>
</property>
<property name="testBeforeUse">
<value>true</value>
</property>
<property name="testAfterUse">
<value>true</value>
</property>
<property name="prototypeCount">
<value>5</value>
</property>
<property name="maximumConnectionCount">
<value>400</value>
</property>
<property name="minimumConnectionCount">
<value>10</value>
</property>
<property name="statistics">
<value>1m,15m,1d</value>
</property>
<property name="statisticsLogLevel">
<value>ERROR</value>
</property>
<property name="trace">
<value>true</value>
</property>
<property name="verbose">
<value>false</value>
</property>
<property name="simultaneousBuildThrottle">
<value>1600</value>
</property>
<property name="maximumActiveTime">
<value>600000</value>
</property>
<property name="jmx">
<value>false</value>
</property>
</bean>
然后注入到sessionFactory中
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="DataSource"/>
</bean>
属性列表说明:
fatal-sql-exception: 它是一个逗号分割的信息片段.当一个SQL异常发生时,他的异常信息将与这个信息片段进行比较.如果在片段中存在,那么这个异常将被认为是个致命错误(Fatal SQL Exception ).这种情况下,数据库连接将要被放弃.无论发生什么,这个异常将会被重掷以提供给消费者.用户最好自己配置一个不同的异常来抛出.
fatal-sql-exception-wrapper-class:正如上面所说,你最好配置一个不同的异常来重掷.利用这个属性,用户可以包装SQLException,使他变成另外一个异常.这个异常或者继承QLException或者继承字RuntimeException.proxool自带了2个实现:'org.logicalcobwebs.proxool.FatalSQLException'和'org.logicalcobwebs.proxool.FatalRuntimeException'.后者更合适.
house-keeping-sleep-time: house keeper 保留线程处于睡眠状态的最长时间,house keeper 的职责就是检查各个连接的状态,并判断是否需要销毁或者创建.
house-keeping-test-sql: 如果发现了空闲的数据库连接.house keeper 将会用这个语句来测试.这个语句最好非常快的被执行.如果没有定义,测试过程将会被忽略。
injectable-connection-interface: 允许proxool实现被代理的connection对象的方法.
injectable-statement-interface: 允许proxool实现被代理的Statement 对象方法.
injectable-prepared-statement-interface: 允许proxool实现被代理的PreparedStatement 对象方法.
injectable-callable-statement-interface: 允许proxool实现被代理的CallableStatement 对象方法.
jmx: 如果属性为true，就会注册一个消息Bean到jms服务，消息Bean对象名: "Proxool:type=Pool, name=<alias>". 默认值为false.
jmx-agent-id: 一个逗号分隔的JMX代理列表(如使用MBeanServerFactory.findMBeanServer(String agentId)注册的连接池。）这个属性是仅当"jmx"属性设置为"true"才有效。所有注册jmx服务器使用这个属性是不确定的
jndi-name: 数据源的名称
maximum-active-time: 如果housekeeper 检测到某个线程的活动时间大于这个数值.它将会杀掉这个线程.所以确认一下你的服务器的带宽.然后定一个合适的值.默认是5分钟.
maximum-connection-count: 最大的数据库连接数.
maximum-connection-lifetime: 一个线程的最大寿命.
minimum-connection-count: 最小的数据库连接数
overload-without-refusal-lifetime: 这可以帮助我们确定连接池的状态。如果我们已经拒绝了一个连接在这个设定值(毫秒),然后被认为是超载。默认为60秒。
prototype-count: 连接池中可用的连接数量.如果当前的连接池中的连接少于这个数值.新的连接将被建立(假设没有超过最大可用数).例如.我们有3个活动连接2个可用连接,而我们的prototype-count是4,那么数据库连接池将试图建立另外2个连接.这和 minimum-connection-count不同. minimum-connection-count把活动的连接也计算在内.prototype-count 是spare connections 的数量.
recently-started-threshold: 这可以帮助我们确定连接池的状态,连接数少还是多或超载。只要至少有一个连接已开始在此值(毫秒)内,或者有一些多余的可用连接,那么我们假设连接池是开启的。默认为60秒
simultaneous-build-throttle: 这是我们可一次建立的最大连接数。那就是新增的连接请求,但还没有可供使用的连接。由于连接可以使用多线程,在有限的时间之间建立联系从而带来可用连接，但是我们需要通过一些方式确认一些线程并不是立即响应连接请求的，默认是10。
statistics: 连接池使用状况统计。 参数“10s,1m,1d”
statistics-log-level: 日志统计跟踪类型。 参数“ERROR”或 “INFO”
test-before-use: 如果为true，在每个连接被测试前都会服务这个连接，如果一个连接失败，那么将被丢弃，另一个连接将会被处理，如果所有连接都失败，一个新的连接将会被建立。否则将会抛出一个SQLException异常。
test-after-use: 如果为true，在每个连接被测试后都会服务这个连接，使其回到连接池中，如果连接失败，那么将被废弃。
trace: 如果为true,那么每个被执行的SQL语句将会在执行期被log记录(DEBUG LEVEL).你也可以注册一个ConnectionListener (参看ProxoolFacade)得到这些信息.
verbose: 详细信息设置。 参数 bool 值
1、Metal风格 (默认)
String lookAndFeel = "javax.swing.plaf.metal.MetalLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
2、Windows风格
String lookAndFeel = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
3、Windows Classic风格
String lookAndFeel = "com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
4、Motif风格
String lookAndFeel = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
5、Mac风格 (需要在相关的操作系统上方可实现)
String lookAndFeel = "com.sun.java.swing.plaf.mac.MacLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
6、GTK风格 (需要在相关的操作系统上方可实现)
String lookAndFeel = "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
7、可跨平台的默认风格
String lookAndFeel = UIManager.getCrossPlatformLookAndFeelClassName();
UIManager.setLookAndFeel(lookAndFeel);
8、当前系统的风格
String lookAndFeel = UIManager.getSystemLookAndFeelClassName();
UIManager.setLookAndFeel(lookAndFeel);
在Java中让用户能够动态地更改应用的外观，可以给用户更好地体验，具体的实现方式是：
1，先使用UIManager.setLookAndFeel(String s)方法设定对应的外观
2，再使用SwingUtilities.updateComponentTreeUI(Component c)方法立刻更新应用的外观
这两个类均在javax.swing包中
相关文章博客：睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬
Java多线程支持需要我们不断的进行相关问题的解决，下面我们就来看看在接口问题上的相关问题解决方案，这样才能更好的进行不断的干洗机创新和学习。希望大家有所了解。
Java多线程支持，所有实现Runnable接口的类都可被启动一个新线程，新线程会执行该实例的run()方法，当run()方法执行完毕后，线程就结束了。一旦一个线程执行完毕，这个实例就不能再重新启动，只能重新生成一个新实例，再启动一个新线程。
Thread类是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法：
1.Thread t = new Thread();
2.t.start();
start()方法是一个native方法，它将启动一个新线程，并执行run()方法。Thread类默认的run()方法什么也不做就退出了。注意：直接调用run()方法并不会启动一个新线程，它和调用一个普通的java多线程支持方法没有什么区别。
因此，有两个方法可以实现自己的线程：
方法1：自己的类extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：
3.public class MyThread extends Thread {
4.public run() {
5.System.out.println("MyThread.run()");
6.}
7.}
在合适的地方启动线程：new MyThread().start();
方法2：如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口：
8.public class MyThread extends OtherClass implements Runnable {
9.public run() {
10.System.out.println("MyThread.run()");
11.}
12.}
为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：
13.MyThread myt = new MyThread();
14.Thread t = new Thread(myt);
15.t.start();
事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：
16.public void run() {
17.if (target != null) {
18.target.run();
19.}
20.}
Java多线程支持还有一些Name, ThreadGroup, isDaemon等设置，由于和线程设计模式关联很少，这里就不多说了。
Java多线程特性为构建高性能的应用提供了极大的方便，但是也带来了不少的麻烦。线程间同步、数据一致性等烦琐的问题需要细心的考虑，一不小心就会出现一些微妙的，难以调试的错误。
另外，应用逻辑和线程逻辑纠缠在一起，会导致程序的逻辑结构混乱，难以复用和维护。本文试图给出一个解决这个问题的方案，通过构建一个并发模型框架（framework），使得开发多线程的应用变得容易。
基础知识
Java语言提供了对于线程很好的支持，实现方法小巧、优雅。对于方法重入的保护，信号量（semaphore）和临界区（critical section）机制的实现都非常简洁。可以很容易的实现多线程间的同步操作从而保护关键数据的一致性。这些特点使得Java成为面向对象语言中对于多线程特性支持方面的佼佼者（C++正在试图把boost库中的对于线程的支持部分纳入语言标准）。
Java中内置了对于对象并发访问的支持，每一个对象都有一个监视器（monitor），同时只允许一个线程持有监视器从而进行对对象的访问，那些没有获得监视器的线程必须等待直到持有监视器的线程释放监视器。对象通过synchronized关键字来声明线程必须获得监视器才能进行对自己的访问。
synchronized声明仅仅对于一些较为简单的线程间同步问题比较有效，对于哪些复杂的同步问题，比如带有条件的同步问题，Java提供了另外的解决方法，wait/notify/notifyAll。
获得对象监视器的线程可以通过调用该对象的wait方法主动释放监视器，等待在该对象的线程等待队列上，此时其他线程可以得到中频点焊机监视器从而访问该对象，之后可以通过调用notify/notifyAll方法来唤醒先前因调用wait方法而等待的线程。
一般情况下，对于wait/notify/notifyAll方法的调用都是根据一定的条件来进行的，比如：经典的生产者/消费者问题中对于队列空、满的判断。熟悉POSIX的读者会发现，使用wait/notify/notifyAll可以很容易的实现POSIX中的一个线程间的高级同步技术：条件变量。
简单例子
本文将围绕一个简单的例子展开论述，这样可以更容易突出我们解决问题的思路、方法。本文想向读者展现的正是这些思路、方法。这些思路、方法更加适用于解决大规模、复杂应用中的并发问题。考虑一个简单的例子，我们有一个服务提供者，它通过一个接口对外提供服务，服务内容非常简单，就是在标准输出上打印Hello World。类结构图如下：
代码如下：
1.interface Service
2.{
3. public void sayHello();
4.}
5.class ServiceImp implements Service
6.{
7. public void sayHello() {
8. System.out.println("Hello World!");
9. }
10.}
11.class Client
12.{
13. public Client(Service s) {
14. _service = s;
15.}
16. public void requestService() {
17. _service.sayHello();
18. }
19. private Service _service;
20.}
如果现在有新的需求，要求该服务必须支持Client的并发访问。一种简单的方法就是在ServicImp类中的每个方法前面加上synchronized声明，来保证自己内部数据的一致性（当然对于本例来说，目前是没有必要的，因为ServiceImp没有需要保护的数据，但是随着需求的变化，以后可能会有的）。但是这样做至少会存在以下几个问题：
1.现在要维护ServiceImp的两个版本：多线程版本和单线程版本（有些地方，比如其他项目，可能没有并发的问题），容易带来点凸焊机同步更新和正确选择版本的问题，给维护带来麻烦。
2.如果多个并发的Client频繁调用该服务，由于是直接同步调用，会造成Client阻塞，降低服务质量。
3.很难进行一些灵活的控制，比如：根据Client的优先级进行排队等等。
4.这些问题对于大型的多线程应用服务器尤为突出，对于一些简单的应用（如本文中的例子）可能根本不用考虑。本文正是要讨论这些问题的解决方案，文中的简单的例子只是提供了一个说明问题，展示思路、方法的平台。
5.如何才能较好的解决这些问题，有没有一个可以重用的解决方案呢？让我们先把这些问题放一放，先来谈谈和框架有关的一些问题。
框架概述
熟悉面向对象的读者一定知道面向对象的最大的优势之一就是：软件复用。通过复用，可以减少很多的工作量，提高软件开发生产率。复用本身也是分层次的，代码级的复用和设计架构的复用。
大家可能非常熟悉C语言中的一些标准库，它们提供了一些通用的功能让你的程序使用。但是这些标准库并不能影响你的程序结构和设计思路，仅仅是提供一些机能，帮助你的程序完成工作。它们使你不必重头编写一般性的通用功能（比如printf），它们强调的是程序代码本身的复用性，而不是设计架构的复用性。
那么什么是框架呢？所谓框架，它不同于一般的标准库，是指一组紧密关联的（类）classes，强调彼此的配合以完成某种可以重复运用的设计概念。这些类之间以特定的方式合作，彼此不可或缺。它们相当程度的影响了你的程序的形貌。框架本身规划了应用程序的骨干，让程序遵循一定的流程和动线，展现一定的风貌和功能。这样就使程序员不必费力于通用性的功能的繁文缛节，集中精力于专业领域。
有一点必须要强调，放之四海而皆准的框架是不存在的，也是最没有用处的。框架往往都是针对某个特定应用领域的，是在对这个应用领域进行深刻理解的基础上，抽象出该应用的概念模型，在这些抽象的概念上搭建的一个模型，是一个有形无体的框架。不同的具体应用根据自身的特点对框架中的抽象概念进行实现，从而赋予框架生命，完成应用的功能。
基于框架的应用都有两部分构成：框架部分和特定应用部分。要想达到框架复用的目标，必须要做到框架部分和特定应用部分的隔离。使用面向对象的一个强大功能：多态，可以实现这一点。在框架中完成抽象概念之间的交互、关联，把具体的实现交给特定的应用来完成。其中一般都会大量使用了Template Method设计模式。Java中的Collection Framework以及微软的MFC都是框架方面很好的例子。有兴趣的读者可以自行研究。
构建框架
如何构建一个Java并发模型框架呢？让我们先回到原来的问题，先来分析一下原因。造成要维护多线程和单线程两个版本的原因是由于把应用逻辑和并发逻辑混在一起，如果能够做到把应用逻辑和并发模型进行很好的隔离，那么应用逻辑本身就可以很好的被复用，而且也很容易把并发逻辑添加进来而不会对应用逻辑造成任何影响。造成Client阻塞，性能降低以及无法进行额外的控制的原因是由于所有的服务调用都是同步的，解决方案很简单，改为异步调用方式，把服务的调用和服务的执行分离。
首先来介绍一个概念，活动对象（Active Object）。所谓活动对象是相对于被动对象（passive object）而言的，被动对象的方法的调用和执行都是在同一个线程中的，被动对象方法的调用是同步的、阻塞的，一般的对象都属于被动对象；主动对象的方法的调用和执行是分离的，主动对象有自己独立的执行线程，主动对象的上海保洁公司方法的调用是由其他线程发起的，但是方法是在自己的线程中执行的，主动对象方法的调用是异步的，非阻塞的。
本框架的核心就是使用主动对象来封装并发逻辑，然后把Client的请求转发给实际的服务提供者（应用逻辑），这样无论是Client还是实际的服务提供者都不用关心并发的存在，不用考虑并发所带来的数据一致性问题。从而实现应用逻辑和并发逻辑的隔离，服务调用和服务执行的隔离。下面给出关键的实现细节。
本框架有如下几部分构成：
1.一个ActiveObject类，从Thread继承，封装了并发逻辑的活动对象；
2.一个ActiveQueue类，主要用来存放调用者请求；
3.一个MethodRequest接口，主要用来封装调用者的请求，Command设计模式的一种实现方式。它们的一个简单的实现如下：
1. //MethodRequest接口定义
2. interface MethodRequest
3.{
4. public void call();
5.}
6.//ActiveQueue定义，其实就是一个producer/consumer队列
7. class ActiveQueue
8.{
9. public ActiveQueue() {
10. _queue = new Stack();
11. }
12. public synchronized void enqueue(MethodRequest mr) {
13. while(_queue.size() > QUEUE_SIZE) {
14. try {
15. wait();
16. }catch (InterruptedException e) {
17. e.printStackTrace();
18. }
19. }
20.
21. _queue.push(mr);
22. notifyAll();
23. System.out.println("Leave Queue");
24. }
25. public synchronized MethodRequest dequeue() {
26. MethodRequest mr;
27.
28. while(_queue.empty()) {
29. try {
30. wait();
31. }catch (InterruptedException e) {
32. e.printStackTrace();
33. }
34. }
35. mr = (MethodRequest)_queue.pop();
36. notifyAll();
37.
38. return mr;
39. }
40. private Stack _queue;
41. private final static int QUEUE_SIZE = 20;
42.}
43.//ActiveObject的定义
44.class ActiveObject extends Thread
45.{
46. public ActiveObject() {
47. _queue = new ActiveQueue();
48. start();
49. }
50. public void enqueue(MethodRequest mr) {
51. _queue.enqueue(mr);
52. }
53. public void run() {
54. while(true) {
55. MethodRequest mr = _queue.dequeue();
56. mr.call();
57. }
58. }
59. private ActiveQueue _queue;
60.}
通过上面的代码可以看出正是这些类相互合作完成了对并发逻辑的封装。开发者只需要根据需要实现MethodRequest接口，另外再定义一个服务代理类提供给使用者，在服务代理者类中把服务调用者的请求转化为MethodRequest实现，交给活动对象即可。
使用该框架，可以较好的做到应用逻辑和并发模型的分离，从而使开发者集中精力于应用领域，然后平滑的和并发模型结合起来，并且可以针对ActiveQueue定制排队机制，比如基于优先级等。
基于框架的解决方案
本小节将使用上述的框架重新实现前面的例子，提供对于并发的支持。第一步先完成对于MethodRequest的实现，对于我们的例子来说实现如下：
1.class SayHello implements MethodRequest
2.{
3. public SayHello(Service s) {
4. _service = s;
5. }
6. public void call() {
7. _service.sayHello();
8. }
9. private Service _service;
10.}
该类完成了对于服务提供接口sayHello方法的封装。接下来定义一个服务代理类，来完成请求的封装、排队功能，当然为了做到对Client透明，该类必须实现Service接口。定义如下：
11.class ServiceProxy implements Service
12.{
13. public ServiceProxy() {
14. _service = new ServiceImp();
15. _active_object = new ActiveObject();
16. }
17.
18. public void sayHello() {
19. MethodRequest mr = new SayHello(_service);
20. _active_object.enqueue(mr);
21. }
22. private Service _service;
23. private ActiveObject _active_object;
24.}
其他的类和接口定义不变，下面对比一下并发逻辑增加前后的服务调用的变化，并发逻辑增加前，对于sayHello服务的调用方法：
25.Service s = new ServiceImp();
26.Client c = new Client(s);
27.c.requestService();
并发逻辑增加后，对于sayHello服务的调用方法：
28.Service s = new ServiceProxy();
29.Client c = new Client(s);
30.c.requestService();
可以看出并发逻辑增加前后对于Client的ServiceImp都无需作任何改变，使用方式也非常一致，ServiceImp也能够独立的进行重用。类结构图如下：
读者容易看出，使用框架也增加了一些复杂性，对于一些简单的应用来说可能根本就没有必要使用本框架。希望读者能够根据自己的实际情况进行判断。
结论
本文围绕一个简单的例子论述了如何构架一个Java并发模型框架，其中使用了一些构建框架的常用技术，当然所构建的框架和一些成熟的商用框架相比，显得非常稚嫩，比如没有考虑服务调用有返回值的情况，但是其思想方法是一致的，希望读者能够深加领会，这样无论对于构建自己的框架还是理解一些其他的框架都是很有帮助的。读者可以对本文中的框架进行扩充，直接应用到自己的工作中。
优点：
1.增强了应用的并发性，简化了同步控制的复杂性；
2.服务的请求和服务的执行分离，使得可以对服务请求排队，进行灵活的控制；
3.应用逻辑和并发模型分离，使得程序结构清晰，易于维护、重用；
4.可以使开发者集中精力于应用领域。
缺点：
1.由于框架所需类的存在，在一定程度上增加了程序的复杂性；
2.如果应用需要过多的活动对象，由于线程切换开销会造成性能下降；
3.可能会造成调试困难。
在Java语言产生前，传统的程序设计语言的程序同一时刻只能单任务操作，效率非常低，例如程序往往在接收数据输入时发生阻塞，只有等到程序获得数据后才能继续运行。随着Internet的迅猛发展，这种状况越来越不能让人们忍受：如果网络接收热合机数据阻塞，后台程序就处于等待状态而不继续任何操作，而这种阻塞是经常会碰到的，此时CPU资源被白白的闲置起来。如果在后台程序中能够同时处理多个任务，该多好啊！应Internet技术而生的Java语言解决了这个问题，多线程程序是Java语言的一个很重要的特点。在一个Java程序中，我们可以同时并行运行多个相对独立的线程，例如，我们如果创建一个线程来进行数据输入输出，而创建另一个线程在后台进行其它的数据处理，如果输入输出线程在接收数据时阻塞，而处理数据的线程仍然在运行。多线程程序设计大大提高了程序执行效率和处理能力。
线程的创建
我们知道Java是面向对象的程序语言，用Java进行程序设计就是设计和使用类，Java为我们提供了线程类Thread来创建线程，创建线程与创建普通的类的对象的操作是一样的，而线程就是Thread类或其子类的实例对象。下面是一个创建启动一个线程的语句：
Thread thread1=new Thread(); file://声明一个对象实例，即创建一个线程；
Thread1.run(); file://用Thread类中的run()方法启动线程；
从这个例子，我们可以通过Thread()构造方法创建一个线程，并启动该线程。事实上，启动线程，也就是启动线程的run()方法，而Thread类中的run()方法没有任何操作语句，所以这个线程没有任何操作。要使线程实现预定功能，必须定义自己的run()方法。Java中通常有两种方式定义 run()方法：
通过定义一个Thread类的子类，在该子类中重写run()方法。Thread子类的实例对象就是一个线程，显然，该线程有我们自己设计的线程体run()方法，启动线程就启动了子类中重写的run()方法。
通过Runnable接口，在该接口中定义run()方法的接口。所谓接口跟类非常类似，主要用来实现特殊功能，如复杂关系的多重继承功能。在此，我们定义一个实现Runnable() 接口的类，在该类中定义自己的run()方法，然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程。
线程被实际创建后处于待命状态，激活（启动）线程就是启动线程的run()方法，这是通过调用线程的start()方法来实现的。
下面一个例子实践了如何通过上述两种方法创建线程并启动它们：
// 通过Thread类的子类创建的线程；
{ file://自定义线程的run()方法；
file://通过Runnable接口创建的另外一个线程；
{ file://自定义线程的run()方法；
file://程序的主类'
class Multi_Thread file://声明主类；
plubic static void mail(String args[]) file://声明主方法；
thread1 threadone=new thread1(); file://用Thread类的子类创建线程；
Thread threadtwo=new Thread(new thread2()); file://用Runnable接口类的对象创建线程；
threadone.start(); threadtwo.start(); file://strat()方法启动线程；
运行该程序就可以看出，线程threadone和threadtwo交替占用CPU，处于并行运行状态。可以看出，启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类)，调用start()方法启动线程的run()方法不同于一般的调用方法，调用一般方法时，必须等到一般方法执行完毕才能够返回start()方法，而启动线程的run()方法后，start()告诉系统该线程准备就绪可以启动run()方法后，就返回 start()方法执行调用start()方法语句下面的语句，这时run()方法可能还在运行，这样，线程的启动和运行并行进行，实现了多任务操作。
线程的优先级
对于多线程程序，每个线程的重要程度是不尽相同，如多个线程在等待获得CPU时间时，往往我们需要优先级高的线程优先抢占到CPU时间得以执行；又如多个线程交替执行时，优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些；这样，高优先级的线程处理的任务效率就高一些。
Java中线程的优先级从低到高以整数1~10表示，共分为10级，设置优先级是通过调用线程对象的setPriority()方法，如上例中，设置优先级的语句为：
thread1 threadone=new thread1(); file://用Thread类的子类创建线程；
Thread threadtwo=new Thread(new thread2()); file://用Runnable接口类的对象创建线程；
threadone.setPriority(6); file://设置threadone的优先级6；
threadtwo.setPriority(3); file://设置threadtwo的优先级3；
threadone.start(); threadtwo.start(); file://strat()方法启动线程；
这样，线程threadone将会优先于线程threadtwo执行，并将占有更多的CPU时间。该例中，优先级设置放在线程启动前，也可以在启动后进行设置，以满足不同的优先级需求。
线程的（同步）控制
一个Java程序的多线程之间可以共享数据。当线程以异步方式访问共享数据时，有时候是不安全的或者不和逻辑的。比如，同一时刻一个线程在读取数据，另外一个线程在处理数据，当处理数据的线程没有等到读取收缩机数据的线程读取完毕就去处理数据，必然得到错误的处理结果。这和我们前面提到的读取数据和处理数据并行多任务并不矛盾，这儿指的是处理数据的线程不能处理当前还没有读取结束的数据，但是可以处理其它的数据。
如果我们采用多线程同步控制机制，等到第一个线程读取完数据，第二个线程才能处理该数据，就会避免错误。可见，线程同步是多线程编程的一个相当重要的技术。
在讲线程的同步控制前我们需要交代如下概念：
1 用Java关键字synchonized同步对共享数据操作的方法
在一个对象中，用synchonized声明的方法为同步方法。Java中有一个同步模型-监视器，负责管理线程对对象中的同步方法的访问，它的原理是：赋予该对象唯一一把'钥匙'，当多个线程进入对象，只有取得该对象钥匙的线程才可以访问同步方法，其它线程在该对象中等待，直到该线程用wait() 方法放弃这把钥匙，其它等待的线程抢占该钥匙，抢占到钥匙的线程后才可得以执行，而没有取得钥匙的线程仍被阻塞在该对象中等待。
file://声明同步的一种方式：将方法声明同步
class store
public synchonized void store_in()
public synchonized void store_out(){
2 利用wait()、notify()及notifyAll()方法发送消息实现线程间的相互联系
Java程序中多个线程通过消息来实现互动联系的，这几种方法实现了线程间的消息发送。例如定义一个对象的synchonized 方法，同一时刻只能够有一个线程访问该对象中的同步方法，其它线程被阻塞。通常可以用notify()或notifyAll()方法唤醒其它一个或所有线程。而使用wait()方法来使该线程处于阻塞状态，等待其它的线程用notify()唤醒。
一个实际的例子就是生产和销售，生产单元将产品生产出来放在仓库中，销售单元则从仓库中提走产品，在这个过程中，销售单元必须在仓库中有产品时才能提货；如果仓库中没有产品，则销售单元必须等待。
程序中，假如我们定义一个仓库类store，该类的实例对象就相当于仓库，在store类中定义两个成员方法：store_in()，用来模拟产品制造者往仓库中添加产品；strore_out()方法则用来模拟销售者从仓库中取走产品。然后定义两个线程类：customer类，其中的run()方法通过调用仓库类中的store_out()从仓库中取走产品，模拟销售者；另外一个线程类producer中的run()方法通过调用仓库类中的 store_in()方法向仓库添加产品，模拟产品制造者。在主类中创建并启动线程，实现向仓库中添加产品或取走产品。
如果仓库类中的store_in() 和store_out()方法不声明同步，这就是个一般的多线程，我们知道，一个程序中的多线程是交替执行的，运行也是无序的，这样，就可能存在这样的问题：
仓库中没有产品了，销售者还在不断光顾，而且还不停的在'取'产品，这在现实中是不可思义的，在程序中就表现为负值；如果将仓库类中的stroe_in ()和store_out()方法声明同步，如上例所示：就控制了同一时刻只能有一个线程访问仓库对象中的同步方法；即一个生产类线程访问被声明为同步的 store_in()方法时，其它线程将不能够访问对象中的store_out()同步方法，当然也不能访问store_in()方法。必须等到该线程调用wait()方法放弃钥匙，其它线程才有机会访问同步方法。
Java代码
1.package com.zbalpha.test;
2.
3.import java.util.ArrayList;
4.import java.util.Iterator;
5.import java.util.List;
6.
7.public class ListTest {
8. public static void main(String args[]){
9. List<Long> lists = new ArrayList<Long>();
10.
11. for(Long i=0l;i<1000000l;i++){
12. lists.add(i);
13. }
14.
15. Long oneOk = oneMethod(lists);
16. Long twoOk = twoMethod(lists);
17. Long threeOk = threeMethod(lists);
18. Long fourOk = fourMethod(lists);
19.
20. System.out.println("One:" + oneOk);
21. System.out.println("Two:" + twoOk);
22. System.out.println("Three:" + threeOk);
23. System.out.println("four:" + fourOk);
24.
25. }
26.
27. public static Long oneMethod(List<Long> lists){
28.
29. Long timeStart = System.currentTimeMillis();
30. for(int i=0;i<lists.size();i++) {
31. System.out.println(lists.get(i));
32. }
33. Long timeStop = System.currentTimeMillis();
34.
35. return timeStop -timeStart ;
36. }
37.
38. public static Long twoMethod(List<Long> lists){
39.
40. Long timeStart = System.currentTimeMillis();
41. for(Long string : lists) {
42. System.out.println(string);
43. }
44. Long timeStop = System.currentTimeMillis();
45.
46. return timeStop -timeStart ;
47. }
48.
49. public static Long threeMethod(List<Long> lists){
50.
51. Long timeStart = System.currentTimeMillis();
52. Iterator<Long> it = lists.iterator();
53. while (it.hasNext())
54. {
55. System.out.println(it.next());
56. }
57. Long timeStop = System.currentTimeMillis();
58.
59. return timeStop -timeStart ;
60. }
61.
62.
63.
64. public static Long fourMethod(List<Long> lists){
65.
66. Long timeStart = System.currentTimeMillis();
67. for(Iterator<Long> i = lists.iterator(); i.hasNext();) {
68. System.out.println(i.next());
69. }
70. Long timeStop = System.currentTimeMillis();
71.
72. return timeStop -timeStart ;
73. }
74.}
容器类可以大大提高编程效率和编程能力，在Java2中，所有的容器都由SUN公司的Joshua Bloch进行了重新设计，丰富了容器类库的功能。
Java2容器类类库的用途是“保存对象”，它分为两类：
Collection----一组独立的元素，通常这些元素都服从某种规则。List必须保持元素特定的顺序，而Set不能有重复元素。
Map----一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，Map可以返回其所有键丰胸组成的Set和其所有值组成的Collection，或其键值对组成的Set，并且还可以像数组一样扩展多维Map，只要让Map中键值对的每个 “值”是一个Map即可。
1.迭代器
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
2.List的功能方法
List(interface): 次序是List最重要的特点；它确保维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(只推荐 LinkedList使用)。一个List可以生成ListIterator，使用它可以从两个方向遍历List，也可以从List中间插入和删除元素。
ArrayList: 由数组实现的List。它允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList，而不是用来插入和删除元素，因为这比LinkedList开销要大很多。
LinkedList: 对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、 addLast()、getFirst()、getLast()、removeFirst()、removeLast()，这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
3.Set的功能方法
Set(interface): 存入Set的每个元素必须是唯一的，因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。
HashSet: 为快速查找而设计的Set。存入HashSet的对象必须定义hashCode()。
TreeSet: 保持次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。
LinkedHashSet: 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
HashSet采用散列函数对元素进行排序，这是专门为快速查询而设计的；TreeSet采用红黑树的数据结构进行排序元素；LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现Comparable接口并定义compareTo()方法。
在java编程思想中对synchronized的一点解释:
1、synchronized关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；
3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
----------------------------------------------------------------------------
java里面synchronized用法
synchronized的一个简单例子
public class TextThread
{
/**
* @param args
*/
public static void main(String[] args)
{
// TODO 自动生成方法存根
TxtThread tt = new TxtThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}
class TxtThread implements Runnable
{
int num = 100;
String str = new String();
public void run()
{
while (true)
{
synchronized(str)
{
if (num>0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
e.getMessage();
}
System.out.println(Thread.currentThread().getName()+ "this is "+ num--);
}
}
}
}
}
上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)
Java对多线程的支持与卫星电视同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。
总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
在进一步阐述之前，我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
接着来讨论synchronized用到不同地方对代码产生的影响：
假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。
1． 把synchronized当作函数修饰符时，示例代码如下：
Public synchronized void methodAAA()
{
//….
}
这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。
上边的示例代码等同于如下代码：
public void methodAAA()
{
synchronized (this) // (1)
{
//…..
}
}
(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（
2．同步块，示例代码如下：
public void method3(SomeObject so)
{
synchronized(so)
{
//…..
}
}
这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：
class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance变量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}
注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
3．将synchronized作用于static 函数，示例代码如下：
Class Foo
{
public synchronized static void methodAAA() // 同步的static 函数
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(类名称字面常量)
}
}
代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的卫星电视对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。
可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。
小结如下：
搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。
还有一些技巧可以让我们对共享资源的同步访问更加安全：
1． 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。
2． 如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。
JDK 5.0 中增加的泛型类型，是 Java 语言中类型安全的一次重要改进。但是，对于初次使用泛型类型的用户来说，泛型的某些方面看起来可能不容易明白，甚至非常奇怪。在本月的“Java 理论和实践”中，Brian Goetz 分析了束缚第一次使用泛型的用户的常见陷阱。您可以通过讨论论坛与作者和其他读者分享您对本文的看法。（也可以单击本文顶端或底端的讨论来访问这个论坛。）
表面上看起来，无论语法还是应用的环境（比如容器类），泛型类型（或者泛型）都类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全在编译器中实现，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除），这项技术有一些奇怪，并且有时会带来一些令人迷惑的后果。虽然范型是 Java 类走向类型安全的一大步，但是在学习使用泛型的过程中几乎肯定会遇到头痛（有时候让人无法忍受）的问题。
注意：本文假设您对 JDK 5.0 中的范型有基本的了解。
泛型不是协变的
虽然将集合看作是数组的抽象会有所帮助，但是数组还有一些集合不具备的特殊性质。Java 语言中的数组是协变的（covariant），也就是说，如果 Integer 扩展了 Number（事实也是如此），那么不仅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求 Number[] 的地方完全可以传递或者赋予 Integer[]。（更正式地说，如果 Number 是 Integer 的超类型，那么 Number[] 也是 Integer[] 的超类型）。您也许认为这一原理同样适用于泛型类型 —— List<Number> 是 List<Integer> 的超类型，那么可以在需要 List<Number> 的地方传递 List<Integer>。不幸的是，情况并非如此。
不允许这样做有一个很充分的理由：这样做将破坏要提供的类型安全泛型。如果能够将 List<Integer> 赋给 List<Number>。那么下面的代码就允许将非 Integer 的内容放入 List<Integer>：
List<Integer> li = new ArrayList<Integer nike jordan 2010>();
List<Number> ln = li; // illegal
ln.add(new Float(3.1415));
因为 ln 是 List<Number>，所以向其添加 Float 似乎是完全合法的。但是如果 ln 是 li 的别名，那么这就破坏了蕴含在 li 定义中的类型安全承诺 —— 它是一个整数列表，这就是泛型类型不能协变的原因。
其他的协变问题
数组能够协变而泛型不能协变的另一个后果是，不能实例化泛型类型的数组（new List<String>[3] 是不合法的），除非类型参数是一个未绑定的通配符（new List<?>[3] 是合法的）。让我们看看如果允许声明泛型类型数组会造成什么后果：
List<String>[] lsa = new List<String>[10]; // illegal
Object[] oa = lsa; // OK because List<String> is a subtype of Object
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[0] = li;
String s = lsa[0].get(0);
最后一行将抛出 ClassCastException，因为这样将把 List<Integer> 填入本应是 List<String> 的位置。因为数组协变会破坏泛型的类型安全，所以不允许实例化泛型类型的数组（除非类型参数是未绑定的通配符，比如 List<?>）。
构造延迟
因为可以擦除功能，所以 List<Integer> 和 List<String> 是同一个类，编译器在编译 List<V> 时只生成一个类（和 C++ 不同）。因此，在编译 List<V> 类时，编译器不知道 V 所表示的类型，所以它就不能像知道类所表示的具体类型那样处理 List<V> 类定义中的类型参数（List<V> 中的 V）。
因为运行时不能区分 List<String> 和 List<Integer>（运行时都是 List），用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息，这给泛型容器类和希望创建保护性副本的泛型类提出了难题。
比如泛型类 Foo：
class Foo<T> {
public void doSomething(T param) { ... }
}
在这里可以看到一种模式 —— 与泛型有关的很多问题或者折衷并非来自泛型本身，而是保持和已有代码兼容的要求带来的副作用。
泛化已有的类
在转化现有的库类来使用泛型方面没有多少技巧，但与平常的情况相同，向后兼容性不会凭空而来。我已经讨论了两个例子，其中向后兼容性限制了类库的泛化。
另一种不同的泛化方法可能不存在向后兼容问题，这就是 Collections.toArray nike shox r4(Object[])。传入 toArray() 的数组有两个目的 —— 如果集合足够小，那么可以将其内容直接放在提供的数组中。否则，利用反射（reflection）创建相同类型的新数组来接受结果。如果从头开始重写 Collections 框架，那么很可能传递给 Collections.toArray() 的参数不是一个数组，而是一个类文字：
interface Collection<E> {
public T[] toArray(Class<T super E> elementClass);
}
因为 Collections 框架作为良好类设计的例子被广泛效仿，但是它的设计受到向后兼容性约束，所以这些地方值得您注意，不要盲目效仿。
首先，常常被混淆的泛型 Collections API 的一个重要方面是 containsAll()、removeAll() 和 retainAll() 的签名。您可能认为 remove() 和 removeAll() 的签名应该是：
interface Collection<E> {
public boolean remove(E e); // not really
public void removeAll(Collection<? extends E> c); // not really
}
但实际上却是：
interface Collection<E> {
public boolean remove(Object o);
public void removeAll(Collection<?> c);
}
为什么呢？答案同样是因为向后兼容性。x.remove(o) 的接口表明“如果 o 包含在 x 中，则删除它，否则什么也不做。”如果 x 是一个泛型集合，那么 o 不一定与 x 的类型参数兼容。如果 removeAll() 被泛化为只有类型兼容时才能调用（Collection<? extends E>），那么在泛化之前，合法的代码序列就会变得不合法，比如：
// a collection of Integers
Collection c = new HashSet();
// a collection of Objects
Collection r = new HashSet();
c.removeAll(r);
如果上述片段用直观的方法泛化（将 c 设为 Collection<Integer>，r 设为 Collection<Object>），如果 removeAll() 的签名要求其参数为 Collection<? extends E> 而不是 no-op，那么就无法编译上面的代码。泛型类库的一个主要目标就是不打破或者改变已有代码的语义，因此，必须用比从头重新设计泛型所使用类型约束更弱的类型约束来定义 remove()、removeAll()、retainAll() 和 containsAll()。
在泛型之前设计的类可能阻碍了“显然的”泛型化方法。这种情况下就要像上例这样进行折衷，但是如果从头设计新的泛型类，理解 Java 类库中的哪些东西是向后兼容的结果很有意义，这样可以避免不适当的模仿。
擦除的实现
因为泛型基本上都是在 Java 编译器中而不是运行库中实现的，所以在生成字节码的时候，差不多所有关于泛型类型的类型信息都被“擦掉”了。换句话说，编译器生成的代码与您手工编写的不用泛型、检查程序的类型安全后进行强制类型转换所得到的代码基本相同。与 C++ 不同，List<Integer> 和 List<String> 是同一个类（虽然是不同的类型但都是 List<?> 的子类型，与以前的版本相比，在 JDK 5.0 中这是一个更重要的区别）。
擦除意味着一个类不能同时实现 Comparable<String> 和 Comparable<Number>，因为事实上两者都在同一个接口中，指定同一个 compareTo() 方法。声明 DecimalString 类以便与 String 与 Number 比较似乎是明智的，但对于 Java 编译器来说，这相当于对同一个方法进行了两次声明：
public class DecimalString implements Comparable fashion cap<Number>, Comparable<String> { ... } // nope
擦除的另一个后果是，对泛型类型参数是用强制类型转换或者 instanceof 毫无意义。下面的代码完全不会改善代码的类型安全性：
public <T> T naiveCast(T t, Object o) { return (T) o; }
编译器仅仅发出一个类型未检查转换警告，因为它不知道这种转换是否安全。naiveCast() 方法实际上根本不作任何转换，T 直接被替换为 Object，与期望的相反，传入的对象被强制转换为 Object。
擦除也是造成上述构造问题的原因，即不能创建泛型类型的对象，因为编译器不知道要调用什么构造函数。如果泛型类需要构造用泛型类型参数来指定类型的对象，那么构造函数应该接受类文字（Foo.class）并将它们保存起来，以便通过反射创建实例。
结束语
泛型是 Java 语言走向类型安全的一大步，但是泛型设施的设计和类库的泛化并非未经过妥协。扩展虚拟机指令集来支持泛型被认为是无法接受的，因为这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。因此采用了可以完全在编译器中实现的擦除方法。类似地，在泛型 Java 类库时，保持向后兼容也为类库的泛化方式设置了很多限制，产生了一些混乱的、令人沮丧的结构（如 Array.newInstance()）。这并非泛型本身的问题，而是与语言的演化与兼容有关。但这些也使得泛型学习和应用起来更让人迷惑，更加困难。
在Web2.0的浪潮中，各种页面技术和框架不断涌现，为服务器端的基础架构提出了更高的稳定性和可扩展性的要求。近年来，作为开源中间件的全球领导者，JBoss在J2EE应用服务器领域已成为发展最为迅速的应用服务器。在市场占有率和服务满意度上取得了巨大的成功，丝毫不逊色于其它的非开源竞争对手，如WebSphere、WebLogic、Application Server。JBoss Web的诸多优越性能，正是其广为流行的原因。
基于Tomcat内核，青胜于蓝
Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可。其运行时占用的系统资源小，扩展性好，且支持负载平衡与邮件服务等开发应用系统常用的功能。作为一个小型的轻量级应用服务器，Tomcat在中小型系统和并发访问用户不是很多的场合下被普遍使用，成为目前比较流行的Web 应用服务器。
而JBoss Web采用业界最优的开源Java Web引擎， 将Java社区中下载量最大，用户数最多，标准支持最完备的Tomcat内核作为其Servlet容器引擎，并加以审核和调优。单纯的Tomcat性能有限，在很多地方表现有欠缺，如活动连接支持、静态内容、大文件和HTTPS等。除了性能问题，Tomcat的另一大缺点是它是一个受限的集成平台，仅能运行Java应用程序。企业在使用时Tomcat，往往还需同时部署Apache Web Server以与之整合。此配置较为繁琐，且不能保证性能的优越性。
JBoss在Tomcat的基础上，对其进行本地化，将Tomcat 以内嵌的方式集成到 JBoss 中。JBoss Web通过使用APR和Tomcat本地技术的混合模型来解决Tomcat的诸多不足。混合技术模型从最新的操作系统技术里提供了最好的线程和事件处理。结果，JBoss Web达到了可扩展性，性能参数匹配甚至超越了本地Apache HTTP服务器或者IIS。譬如JBoss Web能够提供数据库连接池服务，不仅支持 JSP 等 Java 技术，同时还支持其他 Web 技术的集成，譬如 PHP、.NET 两大阵营。
标准化是减小技术依赖风险，保护投资最好的方式。JBoss Web率先支持全系列JEE Web标准，从根本上保证了应用“一次开发，到处运行”的特点，使应用成品能方便地在JBoss Web和其他Java Web服务器之间轻易迁移。
集多功能于一身，性能卓越
作为Web 应用服务器中的明星产品，JBoss Web服务器集多种功能于一身。其关键功能包括：完全支持Java EE、高度的扩展性、快速的静态内容处理、群集、OpenSSL、URL重写和综合性。
JBoss Web服务器具有原生特性和强大的可扩展性，可支持多种并非基于Java的服务器内容处理技术，可同时运行JSP, Servlet, Microsoft .NET , PHP 及 CGI，为其提供一个单一的、高性能的企业级部署平台。
与Tomcat 相比，JBoss Web在静态资源访问方面性能优越。JBoss Web支持两种组件模式——纯Java和Native I/O。在Native组件的支持下，动态运行不会受到任何影响，而静态资源的访问利用了操作系统本身提供的0拷贝传送，CPU消耗降低，响应时间缩短，吞吐率大大提高，混合的连接模式支持最大达到10000个并发客户端的同时访问，与Apache Web服务器相当。部署于高性能的操作系统，可利用JBoss Web对纯Java和Native I/O两种模式的支持，使得应用在开发时可随时跨平台敏捷迁移，而部署于高性能的操作系统相关的Native环境。由于JBoss Web较好地解决了静态资源的访问性能问题，可在解决方案中把它直接作为强大的LVS的分发对象，和RHEL负载均衡系统结合，形成理论上无限线性扩展的负载均衡场景。
OpenSSL是业界最为快速和安全的开源传输组件，可借助操作系统和硬件的特性实现高效的安全承载。JBoss Web集成了OpenSSL，可提供高效的安全传输服务，使得安全机制更上台阶。研究表明， JBoss Web中的SSL性能比单纯的Tomcat快四倍。
URL重写功能可缩短URL，隐藏实际路径提高安全性，易于用户记忆和键入，及被搜索引擎收录。Tomcat 不具备URL重写功能，JBoss Web则可提供一个灵活的URL rewriting操作引擎，支持无限个规则数和规则条件。URL可被重写以支持遗留的URL错误处理，或应对服务器不时产生的其他问题。
JBoss Web既可单独运行，也可无缝嵌入JBoss应用服务器，成为JBoss中间件平台的一部分。不仅后台服务调用的性能将得以提升，也可利用以下JBoss平台的特性提升Web应用功能：
基于JGroups的多种集群方案的支持
基于Arjuna技术的JTA和JTS的事务处理支持
优化的线程池和连接池的支持
基于JMX 控制台的基本管理支持和JBoss On的高级管理维护支持
基于JBoss AOP技术的面向方面架构的支持
Hibernate服务组件的支持
专业团队支持
业界大多数开源产品在技术方面富于创新性，但在可持续性，产品生命周期规划，以及质量保证方面缺乏有效保障，为软件集成商和最终用户所诟病。红帽所力行的“专业化开源技术”则完美解决了这一问题。
来自开源社区的JBoss Web，在红帽专业化开源的锤炼下，在性能、扩展性、稳定性、安全性等方面，已成为一个达到企业级，甚至电信级标准的优秀产品。红帽不仅有专职的技术团队投入JBoss Web的开发，而且具备专门的QA团队为产品作质量保证。完善的集成测试和兼容性测试保证了JBoss Web自身的稳定性，并保证了它的后向兼容和其他JBoss产品协作良好的互操作性。
在服务体系保障方面，JBoss 开拓了以产品专家提供的专家级支持服务作为开源软件强大后盾的软件生态模式。公司以及庞大的 JBoss 授权服务合作伙伴网络可为包括JBoss Web在内的整个JEMS 产品套件提供全面的支持服务。与Tomcat相比，JBoss Web 可提供迁移服务与现场专家服务，在迁移服务方面，专家指导应用可从Tomcat向JBoss Web迁移，省时省力。独特的服务订阅模式，全力保障软件生命周期，让企业高枕无忧。
Tomcat5集群中的SESSION复制
Tomcat 5服务器为集群和SESSION复制提供了集成的支持。本系列的第一篇文章将为大家提供SESSION持久性以及TOMCAT集群中SESSION复制的内在工作机制一个概要认识。我将会讨论SESSION复制在TOMCAT5中是怎样进行的以及跨越多集群节点的SESSION持久性的复制机制。在第2部分，我会详细讨论一个带有SESSION复制功能的TOMCAT集群的安装例子，并且比较不同的复制情形。
集群
传统独立服务器（非集群的）不提供任何失效无缝转移以及负载平衡能力。当服务器失败的时候，就无法获取整个网站的内容，除非服务器被重新唤起。由于服务器失效，任何存储在服务器内存中的SESSION都会丢失，用户必须重新登陆并且输入所有由于服务器失效丢失的数据。
不同的是，作为集群一部分的服务器则提供了可测性以及失效无缝转移能力。一个集群就是一组同步运行并且协同工作，能提供高可靠性，高稳定性以及高可测性的多服务器例程。服务端集群对客户端表现出来似乎就是一个单独的服务器例程。从客户端的视角来看，集群的客户端和单独的服务器没多大不同，但是他们通过提供实效无缝转移和SESSION复制做到了不间断服务以及SESSION数据持久性。
集群中的服务器通讯
集群中的应用程序服务器通过诸如IP多点传送（IP multicast）和IP sockets这样的技术和其他服务器共享信息
●IP多点传送：主要用于1对多的服务器通讯，通过广播服务和 heartbeats消息的可用来显示服务器的有效
●IP sockets：主要用于在集群的服务器例程中进行P2P服务器通讯
使用ip多点传送进行一对多通讯
TOMCAT服务器使用IP多点传送在集群中的服务器例程间进行一对多的通讯，IP多点传送是一种能够让多服务器向指定IP地址和端口号进行订阅并且监听消息的广播技术（多点传送IP地址范围从224.0.0.0 到239.255.255.255）。在集群中的每个服务器都使用多点传送广播特定的 heartbeat消息，通过监视这些 heartbeat消息，在集群中的服务器例程判断什么时候服务器例程失效。在服务器通讯中使用IP多点传送的一个缺点是他不能保证这些消息被确实接收到了。例如，一个应用持续的本地多点传送缓存满了，就不能写入新的多点传送消息，等消息过了之后该应用程序就没有被通知到。
使用ip Sockets进行服务器通讯
IP sockets 同样也通过了一套在集群中的服务器间进行发送消息和数据的机制。服务器例程使用IP sockets 在集群节点间进行HTTP SESSION状态的复制。正确的SOKET配制对于集群的性能是至关重要的，基于SOCKET的通讯的效率取决于SOCKET的实现类别（例如：系统使用本地的或者纯JAVA SOCKET读取器实现），如果服务器使用纯JAVA SOCKET读取器则要看服务器例程是否注册使用了足够的SOCKET读取器线程。
如果想要有最佳的SOCKET性能，系统应该注册使用本地的SOCEKT而不是纯JAVA实现。这是因为相对于基于JAVA的SOCKET实现，本地SOCKET消耗更少的系统资源。虽然SOCKET读取器的JAVA实现是P2P通信中一种可靠而且可移动的方法，可是他不能为集群中的重型SOCKET使用提供最好的性能。当判断从SOCKET是否有数据读取的时候本地SOCKET读取器使用了更有效率的方法。使用本地SOCKET读取器实现，读取器线程不需要去统计静止的SOCKET：他们仅仅为活动的SOCKET服务，并且在一个给定的SOCKET开始活跃起来时他们可以立刻捕捉到。而使用纯JAVA SOCKET读取器，线程必须动态的统计所有打开的SOCKET，判断他们是否包含可读取的数据。换句话说，SOCKET读取器总是忙于统计SOCKET，即使这些SOCKET没有数据可读。这些本不应该的系统开销降低了性能。
TOMCAT 5中的集群
虽然在TOMCAT5的早些版本中也有集群的功能，但是在稍后的版本中（5.0.19或者更高），集群变的更加模块组件化。在 server.XML 中集群元素已经被重构，这样我们可以替换集群的不同部分而不会影响其他元素。例如，当前配置中把成员服务设置为多点传送发现。这里可以轻易地把成员服务修改替换为使用TCP或者 Unicast ，而不会改变集类逻辑的其他部分。
其他一些集群元素，例如SESSION管理器，复制发送端，复制接受端也可以被自定义的实现取代而不影响集群配置的其他部分。同样，在TOMCAT集群中的任何服务器组件可以使用集类API向集群中的所有成员发送消息。
SESSION复制
服务器集群通常操纵两种SESSION： sticky sessions和 replicated sessions .sticky sessions就是存在单机服务器中的接受网络请求的SESSION，其他集群成员对该服务器的SESSION状态完全不清楚，如果存有SESSION的服务器失败的话，用户必须再次登陆网站，重新输入所有存储在SESSION中的数据。
另一种SESSION类型是，在一台服务器中SESSION状态被复制到集群中的其他所有服务器上，无论何时，只要SESSION 被改变，SESSION数据都要重新被复制。这就是 replicated session . sticky 和 replicated sessions都有他们的优缺点， Sticky sessions简单而又容易操作，因为我们不必复制任何SESSION数据到其他服务器上。这样就会减少系统消耗，提高性能。但是如果服务器失败，所有存储在该服务器内存中的SESSION数据也同样会消失。如果SESSION数据没有被复制到其他服务器，这些SESSION就完全丢失了。当我们在进行一个查询事务当中的时候，丢失所有已经输入的数据，就会导致很多问题。
为了支持 jsp HTTP session 状态的自动失效无缝转移，TOMCAT服务器复制了在内存中的SESSION状态。这是通过复制存储在一台服务器上的SESSION数据到集群中其他成员上防止数据丢失以及允许失效无缝转移。
对象的状态管理
通过在服务器上的保存状态可以区分出4种对象：
●无状态：一个无状态对象在调用的时候不会在内存中保存任何状态，因为客户端和服务器端没必要保存任何有关对方的信息。在这种情况下，客户端会在每次请求服务器时都会发送数据给服务器。SESSION状态被在客户端和服务器端来回发送。这种方法不总是可行和理想的，特别是当传输的数据比较大或者一些安全信息我们不想保存在客户端的时候；
●会话：一个会话对象在一个SESSION中只被用于特定的某个客户端。在SESSION中，他可以为所有来自该客户端的请求服务，并且仅仅是这个客户端的请求。贯穿一个SESSION，两个请求间的状态信息必须保存。会话服务通常在内存中保存短暂的状态，当在服务器失败的时候可能会丢失。SESSION状态通常被保存在请求间的服务器的内存中。为了清空内存，SESSION状态也可以被从内存中释放（就像在一个对象CACHE）。在该对象中，性能和可量测性都有待提高，因为更新并不是被单独的写到磁盘上，并且服务器失败的时候数据也没办法抢救。
●缓存：缓存对象在内存中保存状态，并且使用这个去处理从多客户端来的请求。缓存服务的实现可以扩展到他们把缓存的是数据备份保存在后端存储器中（通常是一个关系数据库）。
●独立的：一个独立的对象在一个时间内只活跃在集群中的一台服务器上，处理来自多客户端的请求。他通常由那些私有的，持久的，在内存中缓寸的数据支持。他同样也在内存中保持短暂状态，在服务器失败的时候要重建或者丢失。当失败的时候，独立对象必须在同一个服务器上重起或者移植到另一台服务器上。
SESSION复制的设计考虑事项
网络考虑事项
把集群的多点传送地址和其他应用程序隔离是至关重要的。我们不希望集群配置或者网络布局干扰到多点传送服务器通信。和其他应用程序共享集群多点传送地址将迫使集群的服务器例程处理不应该的消息，消耗系统内存。共享多点传送地址可能也会使IP多点传送缓冲过载，延迟服务器 heartbeat 消息传输。这样的延迟可能导致一个服务器例程被标识为死亡，仅仅因为他的 heartbeat 消息没有被及时接收。
编程考虑事项
除了上面提到的网络相关因素，还有些和我们写 J2EE 网络应用程序有关的设计考虑也会影响SESSION复制。以下列出了一些编程方面的考虑：
●SESSION数据必须被序列化：为了支持HTTP session 状态的内存内复制，所有的 servlet 和 JSP session 数据必须被序列化，对象中的每个域都必须被序列化，这样对象被可靠的序列化。
●把应用程序设计为幂等的：幂等的的意思就是一个操做不会修改状态信息，并且每次操作的时候都返回同样的结果（换句话说就是：做多次和做一次的效果是一样的），通常，WEB请求，特别是 HTML forms 都被发送多次（当用户点击发送按纽两次，重载页面多次），导致多次HTTP请求。设计SERVLET和其他WEB对象为 幂等的，可以容忍多次请求。详细可以去参考设计模式“Synchronized Token ”和“Idempotent Receiver ”关于怎样设计幂等的的应用程序。
●在BUSINESS层存储状态：会话状态应该使用有状态的SESSION BEANS存储在EJB层，而不是存储在WEB层的HttpSession.因为企业应用程序要支持各种类型客户端（WEB客户端，JAVA应用程序，其他EJB），存储数据在WEB层会导致在客户端的双数据存储。因此，有状态的SESSION BEAN在这些情况下就被用于存储SESSION状态。无状态的SESSION BEAN要为每次的调用重构造会话状态。这些状态可能必须从数据库中恢复的数据中重编译。这些缺点失去了使用无状态SESSION BEAN去提高性能和可测量性的目的，严重的减低了性能。
●序列化系统消耗：序列化SESSION数据在复制SESSION状态的时候回会些系统消耗。随着序列化对象大小的增长消耗也越多。最好是保持SESSION容量适当的小。但是如果你必须在SESSION中创建非常大的对象，最好测试下你的 servlets 性能以保证性能是可接受的以及SESSION的复制时间是适当的。
●用户SESSION：判断在集群中每个TOMCAT服务器例程所控制的并发用户SESSION最大数是很重要的。为了控制更多并发SESSION，我们应该为提高效率添加更多内存。最大并发客户端数，以及每个客户端请求的频率在决定SESSION复制对服务器的性能影响方面也是个因素。
Tomcat 5中的SESSION复制
在版本5之前，TOMCAT服务器只支持sticky sessions （使用mod_jk模块进行负载平衡）。如果我们需要SESSION复制，必须依靠第3方软件例如JavaGroups 去实现。
Tomcat 5服务器带有SESSION复制功能。和集群特征类似，只要修改 server.xml 注册文件就能实现SESSION复制。
Martin Fowler 在他的书《 Enterprise Patterns》中谈到三个SESSION状态持久性模式，这些模式包括：
1.客户端SESSION状态：在客户端存储SESSION状态
2.服务端SESSION状态：在一个序列化的FORM中保持SESSION状态到一个服务器系统上。
3.数据库SESSION状态：当在数据库中提交数据的时候存储SESSION数据。
TOMCAT支持以下三种SESSION持久性类型：
1.内存复制：在JVM内存中复制SESSION状态，使用TOMCAT 5安装带的SimpleTcpCluster 和 SimpleTcpClusterManager 类。这些类在包org.apache.catalina.cluster中，是server/lib/catalina-cluster.jar的一部分。
2.数据库持久性：在这种类型中，SESSION状态保存在一个关系数据库中，服务器使用JDBCManager类从数据库中获取SESSION信息。这个类在包org.apache.catalina.session.JDBCStore中，是catalina.jar的一部分。
3.基于文件的持久性：这里使用类PersistenceManager把SESSION状态保存到一个文件系统。这个类在包org.apache.catalina.session.FileStore中，是catalina.jar的一部分。
TOMCAT集群元素以及SESSION复制这章简要介绍一下组成TOMCAT集群的元素以及SESSION复制。
集群：
这个是集群中的主要元素， SimpleTcpCluster类代表这个元素。他使用在server.xml中指定的管理类为所有可分配的web contexts生成ClusterManager.
集群管理器
这个类关注跨越集群中所有节点间的SESSION数据复制。所有在web.xml文件中指定了distributable标记的WEB应用程序都会有SESSION复制。集群管理器作为集群元素的managerClassName属性在server.xml中指定。集群管理器的代码主要被设计用来分离集群中的元素。我们所要做的就是写一个SESSION管理器类去实现ClusterManager接口。这样能让我们灵活的使用客户集群管理器而不会影响到集群中的其他元素。这里有两个复制算法。SimpleTcpReplicationManager每次复制全部的SESSION，而DeltaManager只复制SESSION增量。
最简单的复制管理器在每次HTTP请求都复制所有的SESSION.在SESSION较小的时候这样是很有用的，我们可以只用以下代码：
HashMap map = session.getAttribute（"map"）；map.put（"data"，"data"）；
这里，我们不需要特别调用session.setAttribute（） 或者 removeAttribute方法去复制SESSION变化。对于每次HTTP请求，在SESSION中的所有属性都被复制。可以使用一个叫做useDirtyFlag的属性去最优化SESSION被复制的次数。如果这个标记被设为真，我们必须调用setAttribute（）方法去获取被复制的SESSION变化。如果被设为假，每次请求后SESSION都被复制。
SimpleTcpReplicationManager生成ReplicatedSession执行SESSION复制工作。
提供增量管理器仅仅是为了性能的考虑。它在每次请求的时候都做一次复制。同时他也调用监听器，所以如果我们调用session.setAttribute（），那么在其他服务器上的监听器就会被调用。DeltaManager生成DeltaSession执行 SESSION复制。
成员成员的建立通过由TOMCAT例程在同样的多点传送IP和端口发送广播消息。广播的消息包括服务器的IP地址和TCP监听端口（默认IP地址为228.0.0.4）。
如果在给定的时间框架内一个例程没有接收到消息（由集群配置中的mcastDropTime参数指定），成员被认为死亡。这个元素由McastService类表示。
由mcastXXX开始的属性用于成员资格多点传送PING.以下表格列出了用于IP多点传送服务器通讯的属性。
发送端
这个元素由ReplicationTransmitter类代表。当多点传送广播消息被接收到，成员被添加到机群。在下次复制请求前，发送例程将使用主机和端口信息建立一个TCP SOCKET.使用这些SOCKET发送序列化的数据。在TOMCAT 5中有3种不同的方法操纵SESSION复制：异步，同步，池复制模式。以下部分解释了这些模式怎样工作，以及他们将被使用在什么情况下。
●异步：在这种复制模式中，每个集群节点都有一个单线程扮演SESSION数据传送器。这里，请求线程会把复制请求发送到一个队列，然后返回给客户端。在失效无缝转移前，如果我们拥有sticky sessions，就应该使用异步复制。这里复制时间不是至关重要的，但是请求时间却是。在异步复制期间，请求在数据被复制完之前就返回了。这种复制模式缩短了请求时间。当每个请求被分的更开这种模式是很有用的。（例如，在WEB请求间有更长的延迟）。同样，如果我们不关心SESSION是否完成复制这个也很有用，当SESSION很较小时， SESSION复制时间也更短。
●同步：在这种模式中，一个单线程执行了HTTP请求和数据复制。集群中所有节点都接收到SESSION数据后线程才返回。同步意味被被复制的数据通过一个单SOCKET发送。由于使用一个单线程，同步模式可能会是簇性能的一个潜在的瓶颈。这种复制模式保证了在请求返回前SESSION 已经被复制。
●池：TOMCAT5 在使用池复制模式进行SESSION复制的方法上提供了很大的改进。
池模式基本上是同步模式的一个扩展版本。他基于的一个原则是：划分服务到多例程，每个例程处理不同的SESSION数据片段。同时对接收服务器开放多SOCKET进行发送SESSION信息。这种方法比通过单SOCKET发送所有东西更快。因此，使用一个SOCKET池同步复制SESSION.直到所有SESSION数据都复制完请求才返回。为了有效使用这种模式要增加TCP线程。由于使用多SOCKET，池模式使得集群性能的逐步提高以及更好的可测性。同样这种模式也是最安全的配置，因为它有足够数量的SOCKET在理想的时间内发送所有的SESSION数据到其他节点上。而使用单SOCKET，SESSION数据在通过集群时可能丢失或者只是部分传输。
接收端
这个集群元素由类ReplicationListener表示。在集群配置中以tcpXXX开始的属性用于TCP SESSION复制。以下表格列出了用于配置服务器复制中基于SOCEKT服务器通讯的属性。
复制值
复制值用于判断哪些HTTP请求需要被复制。由于我们不经常复制静态内容（例如HTML和javascript， stylesheets，图像文件），我们可以使用复制值元素过滤掉静态内容。这个值可以用于找出什么时候请求已完成以及初始化复制。
部署器
部署器元素可以用于部署集群范围的应用程序。通常，部署只部署/解除部署簇内的工作成员。所以在损坏的节点在启动时没有WARS的复制。当watchEnabled="true"时配置器为WAR文件监视一个目录（watchDir）。当添加一个新的WAR文件时，WAR被部署到本地例程，然后被部署到集群中的其他例程。当一个WAR文件从watchDir删除，这个WAR被从本地和集群范围内解除部署。
所有在TOMCAT集群结构中的元素以及他们的层次关系都在列在图1中
图 1. Tomcat 集群等级结构图。单击看原图。
TOMCAT中SESSION复制是怎么工作的
以下部分简要解释当TOMCAT服务器启动或则关闭时集群节点怎样分享SESSION信息，详细信息可参考Tomcat 5 Clustering文挡。
TC-01：集群中第一个节点TC-02：集群中第2个节点
●服务器启动：TC-01使用标准服务器启动队列启动。当主机对象被创建，即有一个集群对象和它相关联。当contexts被解析，如果distributable已经在web.xml中指定，那么TOMCAT为WEB CONTEXT创建SESSION管理器（SimpleTcpReplicationManager 取代StandardManager）。集群将会启动一个成员服务（成员的一个例程）和一个复制服务。
当TC-02启动，他也遵循第一个成员（TC-01）同样的队列但是有一个不同。集群被启动并且创建一个成员关系（TC-01，TC-02）。TC-02将向TC-01请求SESSION状态。TC-01回应该请求，在TC-2开始监听HTTP请求前，TC-01发送状态给TC-02.如果TC-01不回应，TC-02将在60秒后进入中止状态并且发布一个日志入口。SESSIONG 状态发送给所有在web.xml中指定了distributable的WEB应用程序。
●创建SESSION：当TC-01接收到请求，一个SESSION（S1）被创建，处理进入TC-01的请求和没有SESSION复制时是一样的。当请求完成时会有以下事件：ReplicationValve将会在回应返回给用户前截取请求。这里，会发现SESSION已经被改变，使用TCP复制SESSION到TC-02.●服务器储运损耗/关闭：当在集群中的一台服务器失败，维护损坏或者系统升级，其他节点会受到第一个节点已经脱离集群的通知。TC-02从他的成员资格列删除TC-01，并且TC-02在也不会收到有关TC-01任何变动的通知。负载平衡将会移至TC-02，所有的SESSION由TC-02控制。
当TC-01开始恢复，他再次遵循在服务器开始阶段描述的启动队列。加入到簇中并且以所有SESSIONG的当前状态和TC-02通讯。一旦接收到 SESSIONG状态，也就完成了加载然后打开它的HTTP/ mod_jk端口。所以，要等到从TC-2接受到SESSION状态TC-01才能发送请求。
●SESSION终止：如果在第一个节点的一个SESSION已经无效或则由于过期终止，无效请求将被截取，SESSION会被同其他无效SESSION放在一个队列中。当请求完成，服务器发送SESSIONG终止消息给TC-02而不是发送已经改变的SESSION，TC-02同样也会把该SESSION置无效。我们可以从服务器控制台看到SESSIONG无效的消息。无效SESSION在集群中将不会被复制，直到其他请求传出系统并且检查无效队列。
我的一个客户不知道该选用Struts还是JSF。就像你预料的那样，我通常会问：这2中框架之间有什么区别？当然，除了我的这个客户外很多人都面临这样的选择。
总的来说，我建议在新项目中优先考虑JSF。虽然常常有一些商业上的因素迫使我们为现有的项目选择了Struts，而且那些解决方案还有待考验，但是，让我们面对一个事实：JSF比Struts好多了。
下面是我选择JSF而不选Struts的十大理由：
1.Components(组件)
2.Render Kits
3.Renderers
4.Value Binding Expressions（值绑定表达式）
5.Event Model（事件模型）
6.Extensibility(可扩展性)
7.Managed Beans(Dependency Injection 依赖注入)
8.POJO Action Methods
9.JSF is the standard Java-based web app framework (JSF是java web应用程序的标准框架)
10.There's only one Struts(只有一个Struts)
10.There's only one Struts(只有一个Struts)
Struts是一个开源产品，然而JSF是一个标准。这个细节常常被新的JSF学习者忽略，其实这是显而易见的，因为我们有多个JSF的实现。虽然JSF还很不成熟，但是我们已经有了2个优秀的JSF实现可以选择：Sun的参考实现和Apache的MyFaces。另一方面，我们只有一个Struts。
9.JSF is the standard(JSF是标准)
JEE 5.0要提供一个JSF的实现，这表明JSF不久将会无处不在。这可能与你无关，但是和工具供应商密切相关。现在大概有50个java web应用程序框架，工具供应商不会情愿去支持一个特别的框架，但是他们会毫不犹豫的去支持一个卫星电视器材标准。而且不止供应商，开源项目也会迅速的聚集在JSF的四周，争先恐后的去实现相同的功能。比如说，直到我们去实现本质上和Shale的Tapestry差不多的视图的时候，我才知道Facalets。（从长远来看，我相信这种冗余是件好事，会给我们带来好处）
8.POJO Action Methods
Struts的行为是和Struts的API绑定在一起的，但是JSF的行为方法可以在POJPO中实现。这意味着你不用在表单和模型对象之间实现一个多余的行为层。顺便说一下，在JSF里面没有行为对象，行为在模型对象中实现。但是也请注意一点：如果你愿意你也可以生成与JSF独立的行为对象。在Struts里面，你有Form. Bean和Action Bean。Form. Bean包含数据而Action Bean包含逻辑。OO狂会想去合并前2者，在Struts你办不到。但是在JSF中，你可以分开数据和逻辑，也可以合并到一个对象中，一切由你决定。
7.Managed Beans(Dependency Injection 依赖注入)
和Spring一样，JSF也使用了依赖注入（DJ）（或控制反转（IoC））去实例化和初始化Bean。Struts的确为你生成了Form. Bean和Action Bean，但是JSF可以为你生成各种各样的Managed Bean。
6.Extensibility(可扩展性)
这个很重要。JSF有6个对象实现了这个框架的大部分功能，而且你可以很容易的用你自己的实现代替原有实现。比如你想加一个自定义参数在JSF表达式语言里面，或是添加一个自己的视图控制器以便于区分组件和HTML。事实上Shale实现了上面的功能。如果你还没有满足，JSF提供了几个地方你可以轻松的控制JSF的生命周期。Shale给你的会更多。
5.Event Model（事件模型）
JSF的事件模型使你可以对值改变，动作，JSF生命周期阶段变换等作出反应。在JSF1.1中，那些事件都是在服务器端处理的，这肯定是一个缺陷，好在JSF2.0计划支持客户端事件，拭目以待吧。
4.Value Binding Expressions（值绑定表达式）
在Struts中，你负责把数据从Form传递到模型对象。你实现的Action的execute方法是把Form作为一个参数。然后你再手动的把数据从Form. Bean里面取出放到模型对象里面。你要为应用里面的每个Form做这些事情，然而在JSF里面，你只需像这样：#{model.property} 就够了，其他的交给JSF来处理。
3.Renderers
你有看过Struts的标签的源代码吗？它直接生成HTML。JSF组件标签什么都不生成，它和服务器上的一对component-renderer对应。Component维护组件状态，rendered负责获得视图。重点是renderers是可插拔的，即你可以根据自己需求实现然后干洗加盟替代掉默认实现。比如说我在NFJS上面的Felix谈话中举例说明了怎么去实现一个自定义的label renderer。你只需要配置你的renderer，JSF就会自动在你的应用程序里面使用他。
2.Render Kits
在几年前我曾经有份Struts咨询工作，我们必须同时支持浏览器和无线设备，非常痛苦。但是用JSF来完成那个任务非常容易，因为你可以生成你自己的render kit－为一种特定显示技术的renderers的集合－然后配置到JSF里面。
1.Components(组件)
组件是Struts和JSF之间最大的区别。就像Swing一样，JSF提供丰富的底层构件去开发组件然后添加到标准的组件集。那些底层构件让你很容易的生成自己的组件并且和别人共享。现在我们到处都能看到自定义组件跳出来，比如说Oracle的ADF和MyFaces，两者都提供了丰富的组件集，就像javascript日历，tree等等。当然，组件只是一部分。典型的是，组件都和一个独立的renderer对应，这给我们带来了真正的好处（看第3条）。但是和JSF中的很多东西一样，你不一定要墨守成规。只要你愿意，你可以实现render自己的组件，虽然这样你会失去给组件加入别的renderer的能力。
定义线程安全性
明确定义线程安全性出人意料地困难，大多数定义看上去完全是自我循环。快速搜索一下 Google，可以找到以下关于线程安全代码的典型的、但是没有多大帮助的定义(或者可以说是描述)：
...可以从多个编程线程中调用，无需线程之间不必要的交互。
...可以同时被多个线程调用，不需要调用一方有任何操作。
有这样的定义，就不奇怪我们对于线程安全性会感到如此迷惑。这些定义比说“一个类在可以被多个线程安全调用时就是线程安全的”好不了多少，当然，它的意义就是如此，但是它不能帮助我们区分一个线程安全的类与一个线程不安全的类。安全的意义是什么呢?
实际上，所有线程安全的定义都有某种程序的循环，因为它必须符合类的规格说明 -- 这是对类的功能、其副作用、哪些状态是有效和无效的、不可变量、前置条件、后置条件等等的一种非正式的松散描述(由规格说明给出的对象状态约束只应用于外部可见的状态，即那些可以通过调用其公共方法和访问其公共字段看到的状态，而不应用于其私有字段中表示的内部状态)。
线程安全性
类要成为线程安全的，首先必须在单线程环境中有正确的行为。如果一个类实现正确(这是说它符合规格说明的另一种方式)，那么没有一种对这个类的对象的操作序列(读或者写公共字段以及调用公共方法)可以让对象处于无效状态，观察到对象处于无效状态、或者违反类的任何不可变量、前置条件或者后置条件的情况。
此外，一个类要成为线程安全的，在被多个线程访问时，不管运行时环境执行这些线程有什么样的时序安排或者交错，它必须仍然有如上所述的正确行为，并且在调用的代码中没有任何额外的同步。其效果就是，在所有线程看来，对于线程安全对象的操作是以固定的、全局一致的顺序发生的。
正确性与线程安全性之间的关系非常类似于在描述 ACID(原子性、一致性、独立性和持久性)事务时使用的一致性与独立性之间的关系：从特定线程的角度看，由不同线程所执行的对象操作是先后(虽然顺序不定)而不是并行执行的。
方法之问的状态依赖
考虑下面的代码片段，它迭代一个 Vector 中的元素。尽管 Vector 的所有方法都是同步的，但是在多线程的环境中不做额外的同步就使用这段代码仍然是不安全的，因为如果另一个线程恰好在错误的时间里删除了一个元素，则 get() 会抛出一个 ArrayIndexOutOfBoundsException 。
1 Vector v = new Vector();
2 // contains race conditions -- may require external synchronization
3 for (int i=0; i<v.size(); i++) {
4 doSomething(v.get(i));
5 }
6
这里发生的事情是： get(index) 的规格说明里有一条前置条件要求 index 必须是非负的并且小于 size() 。但是，在多线程环境中，没有办法可以知道上一次查到的 size() 值是否仍然有效，因而不能确定 i
更明确地说，这一问题是由 get() 的前置条件是以 size() 的结果来定义的这一事实所带来的。只要看到这种必须使用一种方法的结果作为另一种讲法的输入条件的样式，它就是一个 状态依赖，就必须保证干洗设备至少在调用这两种方法期间元素的状态没有改变。一般来说，做到这一点的唯一方法在调用第一个方法之前是独占性地锁定对象，一直到调用了后一种方法以后。在上面的迭代 Vector 元素的例子中，您需要在迭代过程中同步 Vector 对象。
线程安全程度
如上面的例子所示，线程安全性不是一个非真即假的命题。 Vector 的方法都是同步的，并且 Vector 明确地设计为在多线程环境中工作。但是它的线程安全性是有限制的，即在某些方法之间有状态依赖(类似地，如果在迭代过程中 Vector 被其他线程修改，那么由 Vector.iterator() 返回的 iterator 会抛出 ConcurrentModificationException )。
对于 Java 类中常见的线程安全性级别，没有一种分类系统可被广泛接受，不过重要的是在编写类时尽量记录下它们的线程安全行为。
Bloch 给出了描述五类线程安全性的分类方法：不可变、线程安全、有条件线程安全、线程兼容和线程对立。只要明确地记录下线程安全特性，那么您是否使用这种系统都没关系。这种系统有其局限性 -- 各类之间的界线不是百分之百地明确，而且有些情况它没照顾到 -- 但是这套系统是一个很好的起点。这种分类系统的核心是调用者是否可以或者必须用外部同步包围操作(或者一系列操作)。下面几节分别描述了线程安全性的这五种类别。
不可变
本栏目的普通读者听到我赞美不可变性的优点时不会感到意外。不可变的对象一定是线程安全的，并且永远也不需要额外的同步。因为一个不可变的对象只要构建正确，其外部可见状态永远也不会改变，永远也不会看到它处于不一致的状态。Java 类库中大多数基本数值类如 Integer 、 String 和 BigInteger 都是不可变的。
线程安全
线程安全的对象具有在上面“线程安全”一节中描述的属性 -- 由类的规格说明所规定的约束在对象被多个线程访问时仍然有效，不管运行时环境如何排列，线程都不需要任何额外的同步。这种线程安全性保证是很严格的 -- 许多类，如 Hashtable 或者 Vector 都不能满足这种严格的定义。
有条件的线程安全
我们在 7 月份的文件“ 并发集合类”中讨论了有条件的线程安全。有条件的线程安全类对于单独的操作可以是线程安全的，但是某些操作序列可能需要外部同步。条件线程安全的最常见的例子是遍历由 Hashtable 或者 Vector 或者返回的迭代器 -- 由这些类返回的 fail-fast 迭代器假定在迭代器进行遍历的时候底层集合不会有变化。为了保证其他线程不会在遍历的时候改变集合，进行迭代的线程应该确保它是独占性地访问集合以实现遍历的完整性。通常，独占性的访问是由对锁的干洗同步保证的 -- 并且类的文档应该说明是哪个锁(通常是对象的内部监视器(intrinsic monitor))。
如果对一个有条件线程安全类进行记录，那么您应该不仅要记录它是有条件线程安全的，而且还要记录必须防止哪些操作序列的并发访问。用户可以合理地假设其他操作序列不需要任何额外的同步。
线程兼容
线程兼容类不是线程安全的，但是可以通过正确使用同步而在并发环境中安全地使用。这可能意味着用一个 synchronized 块包围每一个方法调用，或者创建一个包装器对象，其中每一个方法都是同步的(就像 Collections.synchronizedList() 一样)。也可能意味着用 synchronized 块包围某些操作序列。为了最大程度地利用线程兼容类，如果所有调用都使用同一个块，那么就不应该要求调用者对该块同步。这样做会使线程兼容的对象作为变量实例包含在其他线程安全的对象中，从而可以利用其所有者对象的同步。
许多常见的类是线程兼容的，如集合类 ArrayList 和 HashMap 、 java.text.SimpleDateFormat 、或者 JDBC 类 Connection 和 ResultSet 。
线程对立
线程对立类是那些不管是否调用了外部同步都不能在并发使用时安全地呈现的类。线程对立很少见，当类修改静态数据，而静态数据会影响在其他线程中执行的其他类的行为，这时通常会出现线程对立。线程对立类的一个例子是调用 System.setOut() 的类。
其他线程安全记录考虑
线程安全类(以及线程安全性程度更低的的类) 可以允许或者不允许调用者锁定对象以进行独占性访问。 Hashtable 类对所有的同步使用对象的内部监视器，但是 ConcurrentHashMap 类不是这样，事实上没有办法锁定一个 ConcurrentHashMap 对象以进行独占性访问。除了记录线程安全程序，还应该记录是否某些锁 -- 如对象的内部锁 -- 对类的行为有特殊的意义。
通过将类记录为线程安全的(假设它确实 是线程安全的)，您就提供了两种有价值的服务：您告知类的维护者不要进行会影响其线程安全性的修改或者扩展，您还告知类的用户使用它时可以不使用外部同步。通过将类记录为线程兼容或者有条件线程安全的，您就告知了用户这个类可以通过正确使用同步而安全地在多线程中使用。通过将类记录为线程对立的，您就告知用户即使使用了外部同步，他们也不能在多线程中安全地使用这个类。不管是哪种情况，您都在潜在的严重问题出现 之前防止了它们，而要查找和修复这些问题是很昂贵的。
结束语
一个类的线程安全行为是其规格说明中的固有部分，应该成为其文档的一部分。因为(还)没有描述类的线程安全行为的声明式方式，所以必须用文字描述。虽然 Bloch 的描述类的线程安全程度的五层系统没有涵盖所有可能的情况，但是它是一个很好的起点。如果每一个类都将这种线程行为的程度加入到其 Javadoc 中，那么可以肯定的是我们大家都会受益。
我们知道，在操作系统级别上软件的运行一般都是以进程为单位，而在每个进程的运行过程中允许同时并发执行多个不同线程，这就使得一个程序能同时执行不同的操作。使用多线程的目的是为了最大限度地利用计算机CPU资源。JAVA程序字节码最终是在JVM虚拟机下运行的，同一虚拟机进程中的不同操作都是通过多线程来运行的。在JAVA虚拟机中，线程常用有单线程和多线程，单线程指程序执行过程只是一个有效操作的序列，不同操作都有着明确的先后顺序；而多线程允许同时进行着不同的操作，这些不同的操作同时并发进行着，并由CPU时钟频率根据不同的调度方式对他们进行执行调度。
在JAVA语言中提供了丰富的多线程操纵接口，提供了各类不同的线程实现方法供我们选择，功能非常强大。在手机软件设计中，由于同样需要执行网络连接（基于HTTP的高级Internet协议通讯）、UI调度等待、UI显示幻化、游戏控制等操作需要通过后台的上海保洁数据运算或UI不断更新等操作。因此在J2ME中，KVM虚拟机也提供了功能强大的多线程API，使我们同样能在J2ME中实现线程的并发运算。
在J2ME中，主要有以下三种方法实现多线程。
一、继承Thread类（java.lang.Thread）
通过编写线程类继承Thread类并重写Thread类中的run（）方法实现线程，当线程对象被运行时候将会自动执行run方法中的实体内容，从而开辟一个单独的线程并运行起来。
如：public class ThreadSimple extends Thread{
public ThreadSimple()
{
//constructor
}
public void run()
{
//run code entity
}
}
线程实例使用，直接创建对象并调用start（）方法即可运行线程。
new ThreadSimple（）。start（）；当执行start方法时候，将会自动运行run方法，但是执行start方法时候只做了一件事，就是将线程转化为可执行状态，然后等待操作系统进行调度并运行，因此无法保证线程能立即启动。在JAVA中，Thread类实现了Runnable接口，因此run方法是通过实现接口Runnable中的抽象方法。
二、直接实现Runnable多线程接口（java.lang.Runnable）
线程接口Runnable中只有一个抽象方法run，通过实现Runnable接口中的方法的类即可创建出有多线程特征的对象，但该对象并无法使其启动线程，需要作为参数并借助Thread的构造方法构造创建对象并调用start方法对线程进行启动。
如：public class RunnablSimple implements Runnable{
public RunnableSimple()
{
//constructor
}
public void run(){
//run code entity
}
}
实现类型的对象使用：
RunnableSimple rs = new RunnableSimple（）；
new Thread（rs）.start（）；
由此可见，以上两种方法都是通过Thread的start来启动线程的，实际上所有的线程操作都是封装在Thread这个类中，由Thread对象调用各种接口来控制线程。
J2ME中线程中主要方法：void setPriority（int newPriority），设置线程优先级，在操作系统中线程的调度是不确定性的，可以通过该方法设置相应线程的优先级别。
static void sleep（long millis） ，线程中静态方法，用于让线程进入休眠状态，执行该方法将会让线程在指定时间millis毫秒内休眠。
void start（），使现在进入可执行状态。
void run（） ，线程执行主体。
void join（），等待该线程终止。
boolean isAlive（），用于判断线程是否出于Alive状态。
static void yield（） ，尽量让其他线程先执行。
三、使用任务组合实现多线程
在J2ME中，同样具有JAVA中的任务处理组合类，他们分别为Timer和TimerTask，可以使用他们实现多线程，简单说就是定时实现任务。
Timer是JAVA中的一个定时器，可以实现在某一时间做某件事或者在某一时间段做某些事，分别通过方法schedule（TimerTask tt，long millis）和schedule（TimerTask tt，long start，long off）。
TimerTask是一个任务类，通过继承该类并覆盖方法run即可创建一个任务。
如：public class TimerTaskS extends TimerTask{
public TimerTaskS(){
//constructor
}
public void run(){
//run code entity
}
}
任务调用：
Timer timer = new Timer（）；
//3秒钟后执行任务
timer.schedule（new TimerTaskS（），3000）；
//3秒钟后执行任务并且之后每5秒钟执行一次
timer.schedule（new TimerTaskS（），3000，5000）；
有此可见在使用计时任务可以达到实现线程的效果，分别执行不同的并发操作，通过Timer类对象来操作TimerTask对象，通过schedule方法来计时执行任务，在结束任务的时候，通常使用cancel（）来实现。
通常情况下，在J2ME软件中我们通过手机按键来触发一系列相应的操作，在程序响应处理过程中较多会涉及网络操作、数据存储等相对消耗时间和资源的操作，而这些操作往往需要一定的时间才能完成，因此在处理按键响应过程中通常我们需要建立干洗设备线程处理，避免程序出现死机现象。
public void commandAction(Command c, Displayable s) {
if(c==do1Com){
//创建实现接口线程
new Thread(new RunnableSimple()).start()；
}
else if(c==do2Com){
//创建继承Thread线程
new ThreadSimple().start();
}
else{
//创建任务线程
new Timer().schedule(new TimerTaskS(),3000,20);
}
}
描述：
计数代理模式在客户对象调用服务提供者对象上方法的前后执行诸如日志（logging）和计数（counting）一系列附加功能时很有用。计数代理模式建议把这些附加功能封装在一个单独的对象，这个对象就是指计数代理对象，而不是把这些附加的功能实现放到服务提供者的内部。良好的对象设计的一个特征就是对象要专注于提供特定的功能。换句话说，理想的对象不应该做各种不相干高周波的事情。把诸如日志（logging）和计数（counting）等类似的功能封装为一个单独的对象，而让服务提供者对象仅提供它自己的特定功能。也就是说，只允许服务提供者对象执行定义良好、特定的任务。
计数代理被设计成可以被客户访问的与服务提供者具有相同接口的对象。客户对象不是直接访问服务提供者，而是调用计数代理对象上的方法，计数代理执行必要的纪录日志（logging）和计数（counting）功能后，再把方法调用传递给服务提供着对象。如图1
Figure1: Generic Class Association When the Counting Proxy Pattern Is Applied
下面的例子说明了如何在应用程序中利用计数代理。
例子：
让我们设计一个Order类，类层次如图2，OrderIF接口声明了getAllOrders读取数据库中所有订单的简单方法。
Figure2: Order Class Hierarchy
public interface OrderIF {
public Vector getAllOrders();
}
作为getAllOrders方法实现的一部分，Order类实用了FileUtil工具类从order.txt文件中读取订单项。
public class Order implements OrderIF {
public Vector getAllOrders() {
FileUtil fileUtil = new FileUtil();
Vector v = fileUtil.fileToVector("orders.txt");
return v;
}
}
让我们假定在调用getAllOrders()时，需要把取数据文件所花费的时间和记录条数要吸亲自出吸塑机记录的log日志文件中。
这个附加的功能可以设计一个单独的OrderProxy类来实现，它与真实对象Order一样实现OrderIF接口。这样保证了OrderProxy对象提供给客户与真实对象Order一样的接口。如图3
Figure3: Order Class Hierarchy with the Counting Proxy
public class OrderProxy implements OrderIF {
private int counter = 0;
public Vector getAllOrders() {
Order order = new Order();
counter++;
long t1 = System.currentTimeMillis ();
Vector v = order.getAllOrders();
long t2 = System.currentTimeMillis();
long timeDiff = t2 ? t1;
String msg = "Iteration=" + counter + "::Time=" + timeDiff + "ms";
//log the message
FileUtil fileUtil = new FileUtil();
fileUtil.writeToFile("log.txt”,msg, true, true);
return v;
}
}
客户对象MainApp就想调用真实对象Order一样调用OrderProxy对象上的getAllOrders()方法，OrderProxy对象传递这个调用给真实对象Order,计算读取所有订单所花费的时间并使用FileUtil帮助类将其纪录的log日志文件中。在这个过程中，OrderProxy扮演者计数代理的角色。
public class MainApp {
public static void main(String[] args) {
OrderIF order = new OrderProxy();
Vector v = order.getAllOrders();
v = order.getAllOrders();
v = order.getAllOrders();
v = order.getAllOrders();
}
}
在 Java 程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为 Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。
为什么会排队等待?
下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ? 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的一种方法是使它成为多线程的。
四项不相关的任务
class myclass {
static public void main(String args[]) {
print_a_file();
manipulate_another_file();
access_database();
draw_picture_on_screen();
}
}
在本例中，每项任务在开始之前必须等待前一项任务完成，即使所涉及的任务毫不相关也是这样。但是，在现实生活中，我们经常使用多线程模型。我们在处理某些任务的同时也可以让孩子、配偶和父母完成别的任务。例如，我在写信的同时可能打发我的儿子去邮局买邮票。用软件术语来说，这称为多个控制(或执行)线程。
可以用两种不同的方法来获得多个控制线程：
多个进程
在大多数操作系统中都可以创建多个进程。当一个程序启动时，它可以为即将开始的每项任务创建一个进程，并允许它们同时运行。当一个程序因等待网络访问或用户输入而被阻塞时，另一个程序还可以运行，这样就增加了干洗设备资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。
线程
线程也称为轻型进程 (LWP)。因为线程只能在单个进程的作用域内活动，所以创建线程比创建进程要廉价得多。这样，因为线程允许协作和数据交换，并且在计算资源方面非常廉价，所以线程比进程更可取。线程需要操作系统的支持，因此不是所有的机器都提供线程。Java 编程语言，作为相当新的一种语言，已将线程支持与语言本身合为一体，这样就对线程提供了强健的支持。
使用 Java 编程语言实现线程
Java编程语言使多线程如此简单有效，以致于某些程序员说它实际上是自然的。尽管在 Java 中使用线程比在其他语言中要容易得多，仍然有一些概念需要掌握。要记住的一件重要的事情是 main() 函数也是一个线程，并可用来做有用的工作。程序员只有在需要多个线程时才需要创建新的线程。
Thread 类
Thread 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个从 Thread 类导出的新类。程序员必须覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数;而是必须调用 Thread 的 start() 函数，该函数再调用 run()。下面的代码说明了它的用法：
创建两个新线程
import java.util.*;
class TimePrinter extends Thread {
int pauseTime;
String name;
public TimePrinter(int x, String n) {
pauseTime = x;
name = n;
}
public void run() {
while(true) {
try {
System.out.println(name + ":" + new
Date(System.currentTimeMillis()));
Thread.sleep(pauseTime);
} catch(Exception e) {
System.out.println(e);
}
}
}
static public void main(String args[]) {
TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
tp1.start();
TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
tp2.start();
}
}
在本例中，我们可以看到一个简单的程序，它按两个不同的时间间隔(1 秒和 3 秒)在屏幕上显示当前时间。这是通过创建两个新线程来完成的，包括 main() 共三个线程。但是，因为有时要作为线程运行的类可能已经是某个类层次的一部分，所以就不能再按这种机制创建干洗机线程。虽然在同一个类中可以实现任意数量的接口，但 Java 编程语言只允许一个类有一个父类。同时，某些程序员避免从 Thread 类导出，因为它强加了类层次。对于这种情况，就要 runnable 接口。
Runnable 接口
此接口只有一个函数，run()，此函数必须由实现了此接口的类实现。但是，就运行这个类而论，其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。(不同的部分用黑体表示。)
创建两个新线程而不强加类层次
import java.util.*;
class TimePrinter implements Runnable {
int pauseTime;
String name;
public TimePrinter(int x, String n) {
pauseTime = x;
name = n;
}
public void run() {
while(true) {
try {
System.out.println(name + ":" + new
Date(System.currentTimeMillis()));
Thread.sleep(pauseTime);
} catch(Exception e) {
System.out.println(e);
}
}
}
static public void main(String args[]) {
Thread t1 = new Thread(new TimePrinter(1000, "Fast Guy"));
t1.start();
Thread t2 = new Thread(new TimePrinter(3000, "Slow Guy"));
t2.start();
}
}
请注意，当使用 runnable 接口时，您不能直接创建所需类的对象并运行它;必须从 Thread 类的一个实例内部运行它。许多程序员更喜欢 runnable 接口，因为从 Thread 类继承会强加类层次。
synchronized 关键字
到目前为止，我们看到的示例都只是以非常简单的方式来利用线程。只有最小的数据流，而且不会出现两个线程访问同一个对象的情况。但是，在大多数有用的程序中，线程之间通常有信息流。试考虑一个金融应用程序，它有一个 Account 对象，如下例中所示：
一个银行中的多项活动
public class Account {
String holderName;
float amount;
public Account(String name, float amt) {
holderName = name;
amount = amt;
}
public void deposit(float amt) {
amount += amt;
}
public void withdraw(float amt) {
amount -= amt;
}
public float checkBalance() {
return amount;
}
}
在此代码样例中潜伏着一个错误。如果此类用于单线程应用程序，不会有任何问题。但是，在多线程应用程序的情况中，不同的线程就有可能同时访问同一个 Account 对象，比如说一个联合帐户的所有者在不同的 ATM 上同时进行访问。在这种情况下，存入和支出就可能以这样的方式发生：一个事务被另一个事务覆盖。这种情况将是灾难性的。但是，Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这样，修订过的 Account 对象(如下所示)将不会遭受像数据损坏这样的错误：
对一个银行中的多项活动进行同步处理
public class Account {
String holderName;
float amount;
public Account(String name, float amt) {
holderName = name;
amount = amt;
}
public synchronized void deposit(float amt) {
amount += amt;
}
public synchronized void withdraw(float amt) {
amount -= amt;
}
public float checkBalance() {
return amount;
}
}
deposit() 和 withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时，另一个函数就被阻塞。请注意， checkBalance() 未作更改，它严格是一个读函数。因为 checkBalance() 未作同步处理，所以任何其他方法都不会阻塞它，它也不会阻塞任何其他方法，不管那些方法是否进行了同步处理。
Java 编程语言中的高级多线程支持
线程组
线程是被个别创建的，但可以将它们归类到线程组中，以便于调试和监视。只能在创建线程的同时将它与一个线程组相关联。在使用大量线程的程序中，使用线程组组织线程可能很有帮助。可以将它们看作是计算机上的目录和文件结构。
线程间发信
当线程在继续执行前需要等待一个条件时，仅有 synchronized 关键字是不够的。虽然 synchronized 关键字阻止并发更新一个对象，但它没有实现线程间发信。Object 类为此提供了三个函数：wait()、notify() 和 notifyAll()。以全球气候预测程序为例。这些程序通过将地球分为许多单元，在每个循环中，每个单元的计算都是隔离进行的，直到这些值趋于稳定，然后相邻单元之间就会交换一些数据。所以，从本质上讲，在每个循环中各个线程都必须等待所有线程完成各自的任务以后才能进入下一个循环。这个模型称为 屏蔽同步，下例说明了这个模型：
屏蔽同步
public class BSync {
int totalThreads;
int currentThreads;
public BSync(int x) {
totalThreads = x;
currentThreads = 0;
}
public synchronized void waitForAll() {
currentThreads++;
if(currentThreads < totalThreads) {
try {
wait();
} catch (Exception e) {}
}
else {
currentThreads = 0;
notifyAll();
}
}
}
当对一个线程调用 wait() 时，该线程就被有效阻塞，只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止。因此，在前一个示例中，不同的线程在完成它们的工作以后将调用 waitForAll() 函数，最后一个线程将触发 notifyAll() 函数，该函数将释放所有的线程。第三个函数 notify() 只通知一个正在等待的线程，当对每次只能由一个线程使用的资源进行访问限制时，这个函数很有用。但是，不可能预知哪个线程会获得这个通知，因为这取决于 Java 虚拟机 (JVM) 调度算法。
将 CPU 让给另一个线程
当线程放弃某个稀有的资源(如数据库连接或网络端口)时，它可能调用 yield() 函数临时降低自己的优先级，以便某个其他线程能够运行。
守护线程
有两类线程：用户线程和守护线程。用户线程是那些完成有用工作的线程。 守护线程是那些仅提供辅助功能的线程。Thread 类提供了 setDaemon() 函数。Java 程序将运行到所有用户线程终止，然后它将破坏所有的守护线程。在 Java 虚拟机 (JVM) 中，即使在 main 结束以后，如果另一个用户线程仍在运行，则程序仍然可以继续运行。
避免不提倡使用的方法
不提倡使用的方法是为支持向后兼容性而保留的那些方法，它们在以后的版本中可能出现，也可能不出现。Java 多线程支持在版本 1.1 和版本 1.2 中做了重大修订，stop()、suspend() 和 resume() 函数已不提倡使用。这些函数在 JVM 中可能引入微妙的错误。虽然函数名可能听起来很诱人，但请抵制诱惑不要使用它们。
调试线程化的程序
在线程化的程序中，可能发生的某些常见而讨厌的情况是死锁、活锁、内存损坏和资源耗尽。
死锁
死锁可能是多线程程序最常见的问题。当一个线程需要一个资源而另一个线程持有该资源的锁时，就会发生死锁。这种情况通常很难检测。但是，解决方案却相当好：在所有的线程中按相同的次序获取所有资源锁。例如，如果有四个资源 ?A、B、C 和 D ? 并且一个线程可能要获取四个资源中任何一个资源的锁，则请确保在获取对 B 的锁之前首先获取对 A 的锁，依此类推。如果“线程 1”希望获取对 B 和 C 的锁，而“线程 2”获取了 A、C 和 D 的锁，则这一技术可能导致阻塞，但它永远不会在这四个锁上造成死锁。
活锁
当一个线程忙于接受新任务以致它永远没有机会完成任何任务时，就会发生活锁。这个线程最终将超出缓冲区并导致程序崩溃。试想一个秘书需要录入一封信，但她一直在忙于接电话，所以这封信永远不会被录入。
内存损坏
如果明智地使用 synchronized 关键字，则完全可以避免内存错误这种气死人的问题。
资源耗尽
某些系统资源是有限的，如文件描述符。多线程程序可能耗尽资源，因为每个线程都可能希望有一个这样的资源。如果线程数相当大，或者某个资源的侯选线程数远远超过了可用的资源数，则最好使用 资源池。一个最好的示例是数据库连接池。只要线程需要使用一个数据库连接，它就从池中取出一个，使用以后再将它返回池中。资源池也称为 资源库。
调试大量的线程
有时一个程序因为有大量的线程在运行而极难调试。在这种情况下，下面的这个类可能会派上用场：
public class Probe extends Thread {
public Probe() {}
public void run() {
while(true) {
Thread[] x = new Thread[100];
Thread.enumerate(x);
for(int i=0; i<100; i++) {
Thread t = x[i];
if(t == null)
break;
else
System.out.println(t.getName() + "\t" + t.getPriority()
+ "\t" + t.isAlive() + "\t" + t.isDaemon());
}
}
}
}
限制线程优先级和调度
Java 线程模型涉及可以动态更改的线程优先级。本质上，线程的优先级是从 1 到 10 之间的一个数字，数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程，然后才调用优先级较低的线程。但是，该标准对具有相同优先级的线程的处理是随机的。如何处理这些线程取决于基层的操作系统策略。在某些情况下，优先级相同的线程分时运行;在另一些情况下，线程将一直运行到结束。请记住，Java 支持 10 个优先级，基层操作系统支持的优先级可能要少得多，这样会造成一些混乱。因此，只能将优先级作为一种很粗略的工具使用。最后的控制可以通过明智地使用 yield() 函数来完成。通常情况下，请不要依靠线程优先级来控制线程的状态。
小结
本文说明了在 Java 程序中如何使用线程。像是否应该使用线程这样的更重要的问题在很大程序上取决于手头的应用程序。决定是否在应用程序中使用多线程的一种方法是，估计可以并行运行的代码量。并记住以下几点：
使用多线程不会增加 CPU 的能力。但是如果使用 JVM 的本地线程实现，则不同的线程可以在不同的处理器上同时运行(在多 CPU 的机器中)，从而使多 CPU 机器得到充分利用。
如果应用程序是计算密集型的，并受 CPU 功能的制约，则只有多 CPU 机器能够从更多的线程中受益。
当应用程序必须等待缓慢的资源(如网络连接或数据库连接)时，或者当应用程序是非交互式的时，多线程通常是有利的。
基于 Internet 的软件有必要是多线程的;否则，用户将感觉应用程序反映迟钝。例如，当开发要支持大量客户机的服务器时，多线程可以使编程较为容易。在这种情况下，每个线程可以为不同的客户或客户组服务，从而缩短了响应时间。
某些程序员可能在 C 和其他语言中使用过线程，在那些语言中对线程没有语言支持。这些程序员可能通常都被搞得对线程失去了信心。
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class RSACoder {
/**
* 得到公钥
* @param key 密钥字符串（经过base64编码）
* @throws Exception
*/
public static PublicKey getPublicKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}
/**
* 得到私钥
* @param key 密钥字符串（经过base64编码）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
/**
* 得到密钥字符串（经过base64编码）
* @return
*/
public static String getKeyString(Key key) throws Exception {
byte[] keyBytes = key.getEncoded();
String s = (new BASE64Encoder()).encode(keyBytes);
return s;
}
public static void main(String[] args) throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
//密钥位数
keyPairGen.initialize(1024);
//密钥对
KeyPair keyPair = keyPairGen.generateKeyPair();
// 公钥
PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
// 私钥
PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
String publicKeyString = getKeyString(publicKey);
System.out.println("public:\n" + publicKeyString);
String privateKeyString = getKeyString(privateKey);
System.out.println("private:\n" + privateKeyString);
//加解密类
Cipher cipher = Cipher.getInstance("RSA");//Cipher.getInstance("RSA/ECB/PKCS1Padding");
//明文
byte[] plainText = "我们都很好！邮件：@sina.com".getBytes();
//加密
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] enBytes = cipher.doFinal(plainText);
//通过密钥字符串得到密钥
publicKey = getPublicKey(publicKeyString);
privateKey = getPrivateKey(privateKeyString);
//解密
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[]deBytes = cipher.doFinal(enBytes);
publicKeyString = getKeyString(publicKey);
System.out.println("public:\n" +publicKeyString);
privateKeyString = getKeyString(privateKey);
System.out.println("private:\n" + privateKeyString);
String s = new String(deBytes);
System.out.println(s);
}
}
最近在开发Java的程序。本来我是一直很喜欢Java的内存管理的，不需要担心分配内存，只管分配，垃圾收集器自己会给你回收内存的。现在开发的程序数据量很大，为了速度快，我准备把所有的信息加载进内存，这样可以保证快速响应。我还在反复算内存，想想自己的数据量，现在刚开始的时候应该够了（我的机器是4G内存，虽然Windows就认3.5G，但是比起我现在的数据量应该没问题）。
没想到第一个实验的程序，跑了几个小时，就遇到了Out of Memory Exception了。看看自己的虚拟机设置，我设置的是-Xms512M -Xmx1024M。想都没想，直接改成-Xms512M -Xmx2048M，结果直接就Could not reserve enough space for object heap。程序都起不来了。这才发现原来最大内存还有限制。上网搜了一下干洗机，发现很多讨论这个问题的文章。最终在BEA的DEV2DEV论坛发现了最有用的一篇http://dev2dev.bea.com.cn/bbs/thread.jspa?forumID=121&threadID= 35704&start=0&tstart=0
这里的版主YuLimin 做了测试，得出结论：
公司 JVM版本 最大内存(兆)client 最大内存(兆)server
SUN 1.5.x 1492 1520
SUN 1.5.5(Linux) 2634 2660
SUN 1.4.2 1564 1564
SUN 1.4.2(Linux) 1900 1260
IBM 1.4.2(Linux) 2047 N/A
BEA JRockit 1.5 (U3) 1909 1902
我现在用的是JDK1.6. 0_05，测试了一下。在Client状态下最大是，我的JDK不认-Server参数，测试不了Server状态。估计差不多。
SUN 1.6.0 1442 N/a
看样子用Java想用大内存也是不可能的了。而且一般的说法是内存太大了，垃圾收集的时间就会长。这也可以理解，一般是内存不够用了才收集的，扫描2G内存比1G当然要慢多了，而且内存对象多了，估计关系是指数上升的。
下面附上YuLimin的测试方法和测试记录。
测试方法：在命令行下用 java -XmxXXXXM -version 命令来进行测试，然后逐渐的增大XXXX的值，如果执行正常就表示指定的内存大小可用，否则会打印错误信息。
测试记录：
我在Windows 2000 ADS上面测试内存使用的结果如下
SUN的1.2.2、1.3.1、1.4.2、1.5.0、IBM1.4.2、BEA JRockit 1.4.2
F:\JDK\1.2.2\bin>java -Xmx700000255M -version
java version “1.2.2″
Classic VM (build JDK-1.2.2_017, native threads, symcjit)
F:\JDK\1.2.2\bin>java -Xmx700000256M -version
Bad max heap size: -Xmx700000256M
Could not create the Java virtual machine.
=====================================================================
F:\JDK\1.3.1\bin>java -version
java version “1.3.1_18″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.1_18-b01)
Java HotSpot(TM) Client VM (build 1.3.1_18-b01, mixed mode)
F:\JDK\1.3.1\bin>REM If present, the option to select the VM must be first.
F:\JDK\1.3.1\bin>REM The default VM is -hotspot.
F:\JDK\1.3.1\bin>java -hotspot -Xmx1554M -version
java version “1.3.1_18″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.1_18-b01)
Java HotSpot(TM) Client VM (build 1.3.1_18-b01, mixed mode)
F:\JDK\1.3.1\bin>java -hotspot -Xmx1555M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
F:\JDK\1.3.1\bin>java -server -Xmx1522M -version
java version “1.3.1_18″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.1_18-b01)
Java HotSpot(TM) Server VM (build 1.3.1_18-b01, mixed mode)
F:\JDK\1.3.1\bin>java -server -Xmx1523M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
F:\JDK\1.3.1\bin>java -classic -Xmx2047M -version
java version “1.3.1_18″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.1_18-b01)
Classic VM (build 1.3.1_18-b01, native threads, nojit)
F:\JDK\1.3.1\bin>java -classic -Xmx2048M -version
Bad max heap size: -Xmx2048M
Could not create the Java virtual machine.
=====================================================================
F:\JDK\1.4.2\bin>java -version
java version “1.4.2_12″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_12-b03)
Java HotSpot(TM) Client VM (build 1.4.2_12-b03, mixed mode)
F:\JDK\1.4.2\bin>REM The default VM is client.
F:\JDK\1.4.2\bin>java -client -Xmx1308M -version
java version “1.4.2_12″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_12-b03)
Java HotSpot(TM) Client VM (build 1.4.2_12-b03, mixed mode)
F:\JDK\1.4.2\bin>java -client -Xmx1309M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
F:\JDK\1.4.2\bin>java -server -Xmx1308M -version
java version “1.4.2_12″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_12-b03)
Java HotSpot(TM) Server VM (build 1.4.2_12-b03, mixed mode)
F:\JDK\1.4.2\bin>java -server -Xmx1309M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
F:\JDK\1.4.2\bin>REM -hotspot is a synonym for the “client” VM [deprecated]
F:\JDK\1.4.2\bin>java -hotspot -Xmx1308M -version
java version “1.4.2_12″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_12-b03)
Java HotSpot(TM) Client VM (build 1.4.2_12-b03, mixed mode)
F:\JDK\1.4.2\bin>java -hotspot -Xmx1309M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
F:\JDK\1.5.0\bin>java -version
java version “1.5.0_07″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_07-b03)
Java HotSpot(TM) Client VM (build 1.5.0_07-b03, mixed mode, sharing)
F:\JDK\1.5.0\bin>java -client -Xmx1492M -version
java version “1.5.0_07″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_07-b03)
Java HotSpot(TM) Client VM (build 1.5.0_07-b03, mixed mode)
F:\JDK\1.5.0\bin>java -client -Xmx1493M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
Could not create the Java virtual machine.
F:\JDK\1.5.0\bin>java -server -Xmx1504M -version
java version “1.5.0_07″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_07-b03)
Java HotSpot(TM) Server VM (build 1.5.0_07-b03, mixed mode)
F:\JDK\1.5.0\bin>java -server -Xmx1505M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
Could not create the Java virtual machine.
F:\JDK\1.5.0\bin>REM -hotspot is a synonym for the “client” VM [deprecated]
F:\JDK\1.5.0\bin>java -hotspot -Xmx1492M -version
java version “1.5.0_07″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_07-b03)
Java HotSpot(TM) Client VM (build 1.5.0_07-b03, mixed mode)
F:\JDK\1.5.0\bin>java -hotspot -Xmx1493M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
Could not create the Java virtual machine.
=====================================================================
F:\JDK\IBM142\bin>java -version
java version “1.4.2″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2)
Classic VM (build 1.4.2, J2RE 1.4.2 IBM Windows 32 build cn1420-20040626 (JIT enabled: jitc))
F:\JDK\IBM142\bin>REM The default VM is client.
F:\JDK\IBM142\bin>java -Xmx2047M -version
java version “1.4.2″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2)
Classic VM (build 1.4.2, J2RE 1.4.2 IBM Windows 32 build cn1420-20040626 (JIT enabled: jitc))
F:\JDK\IBM142\bin>java -Xmx2048M -version
[ Unable to allocate an initial java heap of 2147483648 bytes. ]
[ **Out of memory, aborting** ]
[ ]
[ *** panic: JVMST016: Cannot allocate memory for initial java heap ]
abnormal program termination
F:\BEA\JRockit\bin>java -version
java version “1.4.2_05″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_05-b04)
BEA WebLogic JRockit(TM) 1.4.2_05 JVM R24.4.0-1 (build ari-38120-20041118-1131-win-ia32, Native Threads, GC strategy: parallel)
F:\BEA\JRockit\bin>REM The default VM is jrockit.
F:\BEA\JRockit\bin>java -Xmx1617M -version
java version “1.4.2_05″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_05-b04)
BEA WebLogic JRockit(TM) 1.4.2_05 JVM R24.4.0-1 (build ari-38120-20041118-1131-win-ia32, Native Threads, GC strategy: parallel)
F:\BEA\JRockit\bin>java -Xmx1618M -version
Unable to acquire some virtual address space - reduced from 1656832 to 1640260 KB!
java version “1.4.2_05″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_05-b04)
BEA WebLogic JRockit(TM) 1.4.2_05 JVM R24.4.0-1 (build ari-38120-20041118-1131-win-ia32, Native Threads, GC strategy: parallel)
F:\BEA\JRockit\bin>REM -jrockit to select the “jrockit” VM
F:\BEA\JRockit\bin>java -jrockit -Xmx1617M -version
java version “1.4.2_05″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_05-b04)
BEA WebLogic JRockit(TM) 1.4.2_05 JVM R24.4.0-1 (build ari-38120-20041118-1131-win-ia32, Native Threads, GC strategy: parallel)
F:\BEA\JRockit\bin>java -jrockit -Xmx1618M -version
Unable to acquire some virtual address space - reduced from 1656832 to 1640260 KB!
java version “1.4.2_05″
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_05-b04)
BEA WebLogic JRockit(TM) 1.4.2_05 JVM R24.4.0-1 (build ari-38120-20041118-1131-win-ia32, Native Threads, GC strategy: parallel)
我的测试记录：
C:\>java -client -Xmx1441M -version
java version “1.6.0_05″
Java(TM) SE Runtime Environment (build 1.6.0_05-b13)
Java HotSpot(TM) Client VM (build 10.0-b19, mixed mode)
C:\>java -client -Xmx1442M -version
java version “1.6.0_05″
Java(TM) SE Runtime Environment (build 1.6.0_05-b13)
Java HotSpot(TM) Client VM (build 10.0-b19, mixed mode)
C:\>java -client -Xmx1443M -version
Error occurred during initialization of VM
Could not reserve enough space for object heap
Could not create the Java virtual machine.
C:\>java -server -Xmx1443M -version
Error: no `server’ JVM at `C:\Program Files\Java\jre1.6.0_05\bin\server\jvm.dll’
基本数据的类型的大小是固定的，这里就不多说了。对于非基本类型的Java对象，其大小就值得商榷。
在Java中，一个空Object对象的大小是8byte，这个大小只是保存堆中一个没有任何属性的对象的大小。看下面语句：
Object ob = new Object();
这样在程序中完成了一个Java对象的生命，但是它所占的空间为：4byte+8byte。4byte是上面部分所说的Java栈中保存引用的所需要的空间。而那8byte则是Java堆中对象的信息。因为所有的Java非基本类型的对象都需要默认继承Object对象，因此不论什么样的Java对象，其大小都必须是大于8byte。
有了Object对象的大小，我们就可以计算其他对象的大小了。
Class NewObject { int count; boolean flag; Object ob; }
其大小为：空对象大小(8byte)+int大小(4byte)+Boolean大小(1byte)+空Object引用的大小(4byte)=17byte。但是因为Java在对对象内存分配时都是以8的整数倍来分，因此大于17byte的最接近8的整数倍的是24，因此此对象的大小为24byte。
这里需要注意一下基本类型的包装类型的大小。因为这种包装类型已经成为对象了，因此需要把他们作为对象来看待。包装类型的大小至少是12byte(声明一个空Object至少需要的空间)，而且12byte没有包含任何有效卫星电视信息，同时，因为Java对象大小是8的整数倍，因此一个基本类型包装类的大小至少是16byte。这个内存占用是很恐怖的，它是使用基本类型的N倍(N>2)，有些类型的内存占用更是夸张(随便想下就知道了)。因此，可能的话应尽量少使用包装类。在JDK5.0以后，因为加入了自动类型装换，因此，Java虚拟机会在存储方面进行相应的优化。
引用类型
对象引用类型分为强引用、软引用、弱引用和虚引用。
强引用:就是我们一般声明对象是时虚拟机生成的引用，强引用环境下，垃圾回收时需要严格判断当前对象是否被强引用，如果被强引用，则不会被垃圾回收
软引用:软引用一般被做为缓存来使用。与强引用的区别是，软引用在垃圾回收时，虚拟机会根据当前系统的剩余内存来决定是否对软引用进行回收。如果剩余内存比较紧张，则虚拟机会回收软引用所引用的空间;如果剩余内存相对富裕，则不会进行回收。换句话说，虚拟机在发生OutOfMemory时，肯定是没有软引用存在的。
弱引用:弱引用与软引用类似，都是作为缓存来使用。但与软引用不同，弱引用在进行垃圾回收时，是一定会被回收掉的，因此其生命周期只存在于一个垃圾回收周期内。
强引用不用说，我们系统一般在使用时都是用的强引用。而“软引用”和“弱引用”比较少见。他们一般被作为缓存使用，而且一般是在内存大小比较受限的情况下做为缓存。因为如果内存足够大的话，可以直接使用强引用作为缓存即可，同时可控性更高。因而，他们常见的是被使用在桌面应用系统的缓存。
所有的Hibernate应用中都会访问Hibernate的5个核心接口。
Configuration接口：配置Hibernate,根启动Hibernate，创建SessionFactory对象。
SessionFactory接口：初始化Hibernate，充当数据存储源的代理，创建Session对象。
Session接口：负责保存、更新、删除、加载和查询对象。
Transaction：管理事务。
Query和Criteria接口：执行数据库查询。
1.Configuration接口
Configuration对象用于配置并且启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文件的位置或者动态配置Hibernate的属性，然后创建SessionFactory实例。
2.SessionFactory接口
一个SessionFactory实例对应一个数据存储源，应用从SessionFactory中获得Session实例。SessionFactory有以下特点：
它是线程安全的，这意味着它的同一个实例可以被应用的多个线程共享。
它是重量级的，这意味着不能随意创建或销毁它的实例。如果应用只访问一个数据库，只需要创建一个SessionFactory实例，在应用初始化的时候创建该实例。如果应用同时访问多个数据库，则需要为每个干洗机创建数据库创建一个单独的SessionFactory实例。
之所以称SessionFactory是重量级的，是因为它需要一个很大的缓存，用来存放预定义的SQL语句以能映射元数据等。用户还可以为SesionFactory配置一个缓存插件，这个缓存插件被称为Hibernate的第二级缓存。，该缓存用来存放被工作单元读过的数据，将来其他工作单元可能会重用这些数据，因此这个缓存中的数据能够被所有工作单元共享。一个工作单元通常对应一个数据库事务。
3.Session接口
Session接口是Hibernate应用使用最广泛的接口。Session也被称为持久化管理器，它提供了和持久化相关的操作，如添加、更新、删除、加载和查询对象。
Session有以下特点：
不是线程安全的，因此在设计软件架构时，应该避免多个线程共享同一个Session实例。
Session实例是轻量级的，所谓轻量级，是指它的创建和销毁不需要消耗太多的资源。这意味着在程序中可以经常创建和销毁Session对象，例如为每个客户请示分配单独的Session实例，或者为每个工作单元分配单独的Session实例。
Session有一个缓存，被称为Hibernate的第一级缓存，它存放被当前工作单元加载的对象。每个Session实例都有自己的缓存，这个Sesion实例的缓存只能被当前工作单元访问。
4.Transaction接口
Transaction接口是Hibernate的数据库事务接口，它对底层的事务接口做了封装，底层事务接口包括：
JDBC API、JTA(Java Transaction API)、CORBA(Common Object Requet Broker Architecture)API
Hibernate应用可通过一致的Transaction接口来声明事务边界，这有助于应用在不同的环境容器中移植。尽管应用也可以绕过Transaction接口，直接访问底层的事务接口，这种方法不值得推荐，因为它不利于应用在不同的环境移植。
5.Query和Criteria接口
Query和Criteria接口是Hibernate的查询接口，用于向数据库查询对象，以及控制执行查询的过程。Query实例包装了一个HQL查询语句，HQL查询语句和SQL查询语句有些相似，但HQL查询语句是面向对象的，它引用类句及类的属性句，而不是表句及表的字段句。Criteria接口完全封装了基于字符串的查询语句，比Query接口更加面向对象，Criteria接口擅长执行动态查询。
Session接口的find()方法也具有数据查询功能，但它只是执行一些简单的HQL查询语句的快捷方法，它的功能远没有Query接口强大。
java.lang.Object
org.apache.struts.action.Action
org.apache.struts.actions.DispatchAction
org.apache.struts.actions.LookupDispatchAction(Struts1.1)
org.apache.struts.actions.EventDispatchAction(Struts1.2.9)
org.apache.struts.actions.MappingDispatchAction(Struts1.2)
DispatchAction
public abstract class DispatchAction extends Action
这是一个抽象的Action,它会根据request 中的parameter来执行相应的方法。通个这个Action类可以将不同的Action集中到一个Action文件中来。
struts-config.xml：
<action path="/subscription" type="org.example.SubscriptionAction" name="subscriptionForm" scope="request" input="/subscription.jsp" parameter="method"/>
在Action中要有相应的方法：
public class SubscriptionAction extends DispatchAction {
public ActionForward delete(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward insert(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward update(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
}
然后可以通过这样的方法来访问你的程序：
http://localhost:8080/myapp/subscription.do?method=delete
http://localhost:8080/myapp/subscription.do?method=insert
http://localhost:8080/myapp/subscription.do?method=update
如果parameter中参数为空，则调用Action中的unspecified方法
LookupDispatchAction
public abstract class LookupDispatchAction extends DispatchAction
通过这个Action抽象类继承DispatchAction，它的相应方法的执行由ActionMapping中parameter属性决定。每个动作实际上就是<html:submit>标签的property属性值。它适合在一个form中有很多按钮，按不同的按钮则执行不同的操作。
struts-config.xml：
<action path="/subscription" type="org.example.SubscriptionAction" name="subscriptionForm" scope="request"
input="/subscription.jsp" parameter="method"/>
ApplicationResources.properties：
button.add=Add Record
button.delete=Delete Record
JSP：
<%@ page pageEncoding="GBK"%>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html"%>
<html>
<head>
<title>多提交演示</title>
</head>
<body>
<html:form action="subscription">
<html:submit property="method">
<bean:message key="button.add"/>
</html:submit>
<html:submit property="method">
<bean:message key="button.delete"/>
</html:submit>
</html:form>
</body>
</html>
在Action中必须实现getKeyMethodMap方法：
public class SubscriptionAction extends LookupDispatchAction {
protected Map getKeyMethodMap() {
Map map = new HashMap();
map.put("button.add", "add");
map.put("button.delete", "delete");
return map;
}
public ActionForward add(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward delete(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
}
EventDispatchAction
public class EventDispatchAction extends DispatchAction
通过这个Action抽象类继承DispatchAction，它的相应方法的执行由ActionMapping中parameter属性指定多个动作，中间用逗号(,)分隔。每个动作实际上就是<html:submit>标签的property属性值。它适合在一个form中有很多按钮，按不同的按钮则执行不同的操作。
struts-config.xml：
(parameter中的"recalc=recalculate"意思为<html:submit>标签的property属性值为recalc调用recalculate方法，出于安全考虑能够隐藏后台的业务方法名。"defaule=save"这是可选的，没有配置property属性的<html:submit>标签干洗机将调用defaule中设置的方法名，如果defaule没有指定任何参数，则调用Action中的unspecified方法)
<action path="/subscription" type="org.example.SubscriptionAction" name="subscriptionForm" scope="request"
input="/subscription.jsp" parameter="save,back,recalc=recalculate,default=save"/>
JSP：
<%@ page pageEncoding="GBK"%>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html"%>
<html>
<head>
<title>多提交演示</title>
</head>
<body>
<html:form action="subscription">
<html:submit property="save" value="保存"/>
<html:submit property="back" value="后退"/>
<html:submit property="recalc" value="重新计算"/>
</html:form>
</body>
</html>
在Action中要有相应的方法：
public class SubscriptionAction extends LookupDispatchAction {
public ActionForward save(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward back(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward recalculate(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
}
MappingDispatchAction
public class MappingDispatchAction extends DispatchAction
它的相应方法的执行由ActionMapping中parameter名决定,注意这里和LookupDispatchAction不同，LookupDispatchAction的相应方法的执行由ActionMapping中parameter属性决定。
struts-config.xml：
<action path="/createSubscription" type="org.example.SubscriptionAction" parameter="create">
<forward name="success" path="/createSubscription.jsp"/>
</action>
<action path="/editSubscription" type="org.example.SubscriptionAction" parameter="edit">
<forward name="success" path="/editSubscription.jsp"/>
</action>
<action path="/saveSubscription" type="org.example.SubscriptionAction" parameter="save"
name="subscriptionForm" validate="true" input="/editSubscription.jsp" scope="request">
<forward name="success" path="/savedSubscription.jsp"/>
</action>
<action path="/deleteSubscription" type="org.example.SubscriptionAction" name="subscriptionForm"
scope="request" input="/subscription.jsp" parameter="delete">
<forward name="success" path="/deletedSubscription.jsp"/>
</action>
<action path="/listSubscriptions" type="org.example.SubscriptionAction" parameter="list">
<forward name="success" path="/subscriptionList.jsp"/>
</action>
在Action中要有相应的方法：
public class SubscriptionAction extends MappingDispatchAction {
public ActionForward create(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward edit(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward save(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward delete(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
public ActionForward list(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {}
}
在很多Web应用中，为了完成不同的工作，一个HTML form标签中可能有两个或多个submit按钮，如下面的代码所示：
<!--[if !supportLineBreakNewLine]-->
<html action="" method="post">
<input type="submit" value="保存" />
<input type="submit" value="打印" />
</html>
由于在<form>中的多个提交按钮都向一个action提交，使用Struts2 Action的execute方法就无法判断用户点击了哪一个提交按钮。如果大家使用过Struts1.x就会知道在Struts1.2.9之前的版本需要使用一个LookupDispatchAction动作来处理含有多个submit的form。但使用LookupDispatchAction动作需要访问属性文件，还需要映射，比较麻烦。从Struts1.2.9开始，加入了一个EventDispatchAction动作。这个类可以通过java 反射来调用通过request参数指定的动作（实际上只是判断某个请求参数是不存在，如果存在，就调用在action类中和这个参数同名的方法）。使用 EventDispatchAction必须将submit的name属性指定不同的值以区分每个submit。而在Struts2中将更容易实现这个功能。
当然，我们也可以模拟EventDispatchAction的方法通过request获得和处理参数信息。但这样比较麻烦。在Struts2中提供了另外一种方法，使得无需要配置可以在同一个action类中执行不同的方法（默认执行的是execute方法）。使用这种方式也需要通过请求参来来指定要执行的动作。请求参数名的格式为
action!method.action
注：由于Struts2只需要参数名，因此，参数值是什么都可以。
下面我就给出一个实例程序来演示如何处理有多个submit的form：
【第1步】实现主页面(more_submit.jsp)
<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>My JSP 'hello.jsp' starting page</title>
</head>
<body>
<s:form action="submit.action" >
<s:textfield name="msg" label="输入内容"/>
<s:submit name="save" value="保存" align="left" method="save"/>
<s:submit name="print" value="打印" align="left" method="print" />
</s:form>
</body>
</html>
在more_submit.jsp中有两个submit：保存和打印。其中分别通过method属性指定了要调用的方法：save和print。因此，在Action类中必须要有save和print方法。
【第2步】实现Action类（MoreseoSubmitAction）
package action;
import javax.servlet.http.*;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.interceptor.*;
public class MoreSubmitAction extends ActionSupport implements
ServletRequestAware {
private String msg;
private javax.servlet.http.HttpServletRequest request;
// 获得HttpServletRequest对象
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
// 处理save submit按钮的动作
public String save() throws Exception {
request.setAttribute("result", "成功保存[" + msg + "]");
return "save";
}
// 处理print submit按钮的动作
public String print() throws Exception {
request.setAttribute("result", "成功打印[" + msg + "]");
return "print";
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
上面的代码需要注意如下两点：
save和print方法必须存在，否则会抛出java.lang.NoSuchMethodException异常。
Struts2 Action动作中的方法和Struts1.x Action的execute不同，只使用Struts2 Action动作的execute方法无法访问request对象，因此，Struts2 Action类需要实现一个Struts2自带的拦截器来获得request对象，拦截器如下：
org.apache.struts2.interceptor. ServletRequestAware
【第3步】配置Struts2 Action
struts.xml的代码如下：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="demo" extends="struts-default" >
<action name="submit" class="action.MoreSubmitAction">
<result name="save" >
/result.jsp
</result>
<result name="print">
/result.jsp
</result>
</action>
</package>
</struts>
【第4步】编写结果页（result.jsp） <%@ page pageEncoding="GBK"%>
<html>
<head>
<title>提交结果</title>
</head>
<body>
<h1>${result}</h1>
</body>
</html>
在result.jsp中将在save和print方法中写到request属性中的执行结果信息取出来，并输出到客户端。
用过struts1.x的人都知道，标签库有html、bean、logic、tiles，而struts2.0里的标签却没有分类，只用在jsp头文件加上
<%@ taglib prefix="s" uri="/struts-tags" %>
就能使用struts2.0的标签库
A：
<s:a href=""></s:a>-----超链接，类似于html里的<a></a>
<s:action name=""></s:action>-----执行一个view里面的一个action
<s:actionerror/>-----如果action的errors有值那么显示出来
<s:actionmessage/>-----如果action的message有值那么显示出来
<s:append></s:append>-----添加一个值到list，类似于list.add();
<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容，这个是ajax
B：
<s:bean name=""></s:bean>-----类似于struts1.x中的，JavaBean的值
C：
<s:checkbox></s:checkbox>-----复选框
<s:checkboxlist list=""></s:checkboxlist>-----多选框
<s:combobox list=""></s:combobox>-----下拉框
<s:component></s:component>-----图像符号
D：
<s:date/>-----获取日期格式
<s:datetimepicker></s:datetimepicker>-----日期输入框
<s:debug></s:debug>-----显示错误信息
<s:div></s:div>-----表示一个块，类似于html的<div></div>
<s:doubleselect list="" doubleName="" doubleList=""></s:doubleselect>-----双下拉框
E：
<s:if test=""></s:if>
<s:elseif test=""></s:elseif>
<s:else></s:else>-----这3个标签一起使用，表示条件判断
F：
<s:fielderror></s:fielderror>-----显示文件错误信息
<s:file></s:file>-----文件上传
<s:form action=""></s:form>-----获取相应form的值
G：
<s:generator separator="" val=""></s:generator>----和<s:iterator>标签一起使用
H：
<s:head/>-----在<head></head>里使用，表示头文件结束
<s:hidden></s:hidden>-----隐藏值
I：
<s:i18n name=""></s:i18n>-----加载资源包到值堆栈
<s:include value=""></s:include>-----包含一个输出，servlet或jsp页面
<s:inputtransferselect list=""></s:inputtransferselect>-----获取form的一个输入
<s:iterator></s:iterator>-----用于遍历集合
L：
<s:label></s:label>-----只读的标签
M：
<s:merge></s:merge>-----合并遍历集合出来的值
O：
<s:optgroup></s:optgroup>-----获取标签组
<s:optiontransferselect doubleList="" list="" doubleName=""></s:optiontransferselect>-----左右选择框
P：
<s:param></s:param>-----为其他标签提供参数
<s:password></s:password>-----密码输入框
<s:property/>-----得到'value'的属性
<s:push value=""></s:push>-----value的值push到栈中,从而使property标签的能够获取value的属性
R：
<s:radio list=""></s:radio>-----单选按钮
<s:reset></s:reset>-----重置按钮
S：
<s:select list=""></s:select>-----单选框
<s:set name=""></s:set>-----赋予变量一个特定范围内的值
<s:sort comparator=""></s:sort>-----通过属性给list分类
<s:submit></s:submit>-----提交按钮
<s:subset></s:subset>-----为遍历集合输出子集
T：
<s:tabbedPanel id=""></s:tabbedPanel>-----表格框
<s:table></s:table>-----表格
<s:text name=""></s:text>-----I18n文本信息
<s:textarea></s:textarea>-----文本域输入框
<s:textfield></s:textfield>-----文本输入框
<s:token></s:token>-----拦截器
<s:tree></s:tree>-----树
<s:treenode label=""></s:treenode>-----树的结构
U：
<s:updownselect list=""></s:updownselect>-----多选择框
<s:url></s:url>-----创建url
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用javascript来操作DOM而更新页面。这其中最关键的一步就是从服务器获得请求数据。要清楚这个过程和原理，我们必须对 XMLHttpRequest有所了解。
XMLHttpRequest是ajax的核心机制，它是在IE5中首先引入的，是一种支持异步请求的技术。简单的说，也就是javascript可以及时向服务器提出请求和处理响应，而不阻塞用户。达到无刷新的效果。
所以我们先从XMLHttpRequest讲起，来看看它的工作原理。
首先，我们先来看看XMLHttpRequest这个对象的属性。
它的属性有：
onreadystatechange 每次状态改变所触发事件的事件处理程序。
responseText 从服务器进程返回数据的字符串形式。
responseXML 从服务器进程返回的DOM兼容的文档数据对象。
status 从服务器返回的数字代码，比如常见的404（未找到）和200（已就绪）
status Text 伴随状态码的字符串信息
readyState 对象状态值
0 (未初始化) 对象已建立，但是尚未初始化（尚未调用open方法）
1 (初始化) 对象已建立，尚未调用send方法
2 (发送数据) send方法已调用，但是当前的状态及http头未知
3 (数据传送中) 已接收部分数据，因为响应及http头不全，这时通过responseBody和responseText获取部分数据会出现错误，
4 (完成) 数据接收完毕,此时可以通过通过responseXml和responseText获取完整的回应数据
但是，由于各浏览器之间存在差异，所以创建一个XMLHttpRequest对象可能需要不同的方法。这个差异主要体现在IE和其它浏览器之间。下面是一个比较标准的创建XMLHttpRequest对象的方法。
function CreateXmlHttp()
{
//非IE浏览器创建XmlHttpRequest对象
if(window.XmlHttpRequest)
{
xmlhttp=new XmlHttpRequest();
}
//IE浏览器创建XmlHttpRequest对象
if(window.ActiveXObject)
{
try
{
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
catch(e)
{
try{
xmlhttp=new ActiveXObject("msxml2.XMLHTTP");
}
catch(ex){}
}
}
}
function Ustbwuyi()
{
var data=document.getElementById("username").value;
CreateXmlHttp();
if(!xmlhttp)
{
alert("创建xmlhttp对象异常！");
return false;
}
xmlhttp.open("POST",url,false);
xmlhttp.onreadystatechange=function()
{
if(xmlhttp.readyState==4)
{
document.getElementById("user1").innerHTML="数据正在加载...";
if(xmlhttp.status==200)
{
document.write(xmlhttp.responseText);
}
}
}
xmlhttp.send();
}
如上所示，函数首先检查XMLHttpRequest的整体状态并且保证它已经完成（readyStatus=4），即数据已经发送完毕。然后根据服务器的设定询问请求状态，如果一切已经就绪（status=200），那么就执行下面需要的操作。
对于XmlHttpRequest的两个方法，open和send，其中open方法指定了：
a、向服务器提交数据的类型，即post还是get。
b、请求的url地址和传递的参数。
c、传输方式，false为同步，true为异步。默认为true。如果是异步通信方式(true)，客户机就不等待服务器的响应；如果是同步方式(false)，客户机就要等到服务器返回消息后才去执行其他操作。我们需要根据网站优化实际需要来指定同步方式，在某些页面中，可能会发出多个请求，甚至是有组织有计划有队形大规模的高强度的request，而后一个是会覆盖前一个的，这个时候当然要指定同步方式。
Send方法用来发送请求。
知道了XMLHttpRequest的工作流程，我们可以看出，XMLHttpRequest是完全用来向服务器发出一个请求的，它的作用也局限于此，但它的作用是整个ajax实现的关键，因为ajax无非是两个过程，发出请求和响应请求。并且它完全是一种客户端的技术。而XMLHttpRequest正是处理了服务器端和客户端通信的问题所以才会如此的重要。
现在，我们对ajax的原理大概可以有一个了解了。我们可以把服务器端看成一个数据接口，它返回的是一个纯文本流，当然，这个文本流可以是XML格式，可以是Html，可以是Javascript代码，也可以只是一个字符串。这时候，XMLHttpRequest向服务器端请求这个页面，服务器端将文本的结果写入页面，这和普通的web开发流程是一样的，不同的是，客户端在异步获取这个结果后，不是直接显示在页面，而是先由javascript来处理，然后再显示在页面。至于现在流行的很多ajax控件，比如magicajax等，可以返回DataSet等其它数据类型，只是将这个过程封装了的结果，本质上他们并没有什么太大的区别。
线程的同步是保证多线程安全访问竞争资源的一种手段。
线程的同步是Java多线程编程的难点，往往开发者搞不清楚什么是竞争资源、什么时候需要考虑同步，怎么同步等等问题，当然，这些问题没有很明确的答案，但有些原则问题需要考虑，是否有竞争资源被同时改动的问题？
在本文之前，请参阅《Java线程：线程的同步与锁》，本文是在此基础上所写的。
对于同步，在具体的Java代码中需要完成一下两个操作：
把竞争访问的资源标识为private；
同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。
当然这不是唯一控制并发安全的途径。
synchronized关键字使用说明
synchronized只能标记非抽象的方法，不能标识成员变量。
为了演示同步方法的使用，构建了一个信用卡账户，起初信用额为100w，然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源，而多个并发操作的是账户方法oper(int x)，当然应该在此方法上加上同步，并将账户的余额设为私有变量，禁止直接访问。
/**
* Java线程：线程的同步
*
* @author leizhimin 2009-11-4 11:23:32
*/
public class Test {
public static void main(String[] args) {
User u = new User("张三", 100);
MyThread t1 = new MyThread("线程A", u, 20);
MyThread t2 = new MyThread("线程B", u, -60);
MyThread t3 = new MyThread("线程C", u, -80);
MyThread t4 = new MyThread("线程D", u, -30);
MyThread t5 = new MyThread("线程E", u, 32);
MyThread t6 = new MyThread("线程F", u, 21);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
class MyThread extends Thread {
private User u;
private int y = 0;
MyThread(String name, User u, int y) {
super(name);
this.u = u;
this.y = y;
}
public void run() {
u.oper(y);
}
}
class User {
private String code;
private int cash;
User(String code, int cash) {
this.code = code;
this.cash = cash;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
/**
* 业务方法
* @param x 添加x万元
*/
public synchronized void oper(int x) {
try {
Thread.sleep(10L);
this.cash += x;
System.out.println(Thread.currentThread().getName() + "运行结束，增加“" + x + "”，当前用户账户余额为：" + cash);
Thread.sleep(10L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return "User{" +
"code='" + code + '\'' +
", cash=" + cash +
'}';
}
}
输出结果：
线程A运行结束，增加“20”，当前用户账户余额为：120
线程F运行结束，增加“21”，当前用户账户余额为：141
线程E运行结束，增加“32”，当前用户账户余额为：173
线程C运行结束，增加“-80”，当前用户账户余额为：93
线程B运行结束，增加“-60”，当前用户账户余额为：33
线程D运行结束，增加“-30”，当前用户账户余额为：3
Process finished with exit code 0
反面教材，不同步的情况，也就是去掉oper(int x)方法的synchronized修饰符，然后运行程序，结果如下：
线程A运行结束，增加“20”，当前用户账户余额为：61
线程D运行结束，增加“-30”，当前用户账户余额为：63
线程B运行结束，增加“-60”，当前用户账户余额为：3
线程F运行结束，增加“21”，当前用户账户余额为：61
线程E运行结束，增加“32”，当前用户账户余额为：93
线程C运行结束，增加“-80”，当前用户账户余额为：61
Process finished with exit code 0
很显然，上面的结果是错误的，导致错误的原因是多个线程并发访问了竞争资源u，并对u的属性做了改动。
可见同步的重要性。
注意：
通过前文可知，线程退出同步方法时将释放掉方法所属对象的锁，但还应该注意的是，同步方法中还可以使用特定的方法对线程进行调度。这些方法来自于java.lang.Object类。
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
void wait()
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
void wait(long timeout)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
void wait(long timeout, int nanos)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
结合以上方法，处理多线程同步与互斥问题非常重要，著名的生产者-消费者例子就是一个经典的例子，任何语言多线程必学的例子。