两种方法：

法一：先WebWork后Spring（利用webwork2-spring.jar集成）

该方法的执行顺序是先WebWork，后Spring。
即，首先在xwork.xml中找到待执行的action，如果该action依赖其他bean，再到applicationContext.xml中查找被依赖的bean。

WebWork2的IoC功能实现是在xwork.xml中，指定action类与其他bean的依赖关系。即：
(1)xwork.xml文件
<action name="myAction" class="com.ryandaigle.web.actions.MyAction">
<external-ref name="DAO">myDAO</external-ref>
<result name="success" type="dispatcher">
<param name="location">/success.jsp</param>
</result>
</action>

(2)applicationContext.xml文件
<bean id="myDAO" class="com.ryandaigle.persistence.MyDAO" singleton="true" />

具体集成步骤如下：

1. 下载以下文件：
http://www.ryandaigle.com/pebble/images/webwork2-spring.jar

2. 配置xwork.xml

2.1 在xwork.xml中定义action时，采用external-ref来指定依赖的spring bean

<action name="myAction" class="com.foo.Action">
<external-ref name="someDao">someDao</external-ref>

<result name="success" type="dispatcher">
<param name="location">/success.jsp</param>
</result>
</action>

2.2 在<package>中指定外部引用解析器

<package name="default" extends="webwork-default"
externalReferenceResolver="com.atlassian.xwork.ext.SpringServletContextReferenceResolver"/>

SpringServletContextReferenceResolver作用是在applicationContext.xml中解析外部引用的bean

2.3 增加一个拦截器，允许引用作为外部资源进行解析
<interceptors>
<interceptor name="reference-resolver" class="com.opensymphony.xwork.interceptor.ExternalReferencesInterceptor"/>
<interceptor-stack name="myDefaultWebStack">
<interceptor-ref name="defaultStack"/>
<interceptor-ref name="reference-resolver"/>
</interceptor-stack>
</interceptors>
<default-interceptor-ref name="myDefaultWebStack"/>

3. 在web.xml中配置Spring与XWork的外部解析器在同一个Web Context中工作
<!--载入spring配置文件-->
 <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:/applicationContext.xml
        </param-value>
    </context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<listener>
<listener-class>com.atlassian.xwork.ext.ResolverSetupServletContextListener</listener-class>
</listener>

第一个侦听器是spring必需的，无论是否与WebWork集成，都要定义该侦听器；第二个侦听器是外部解析器所需要的，作用是通过ServletContext来取出Spring的ApplicationContext，作为WebWork与Spring的“桥梁”。

4.applicationContext.xml文件跟xwork.xml文件的存放路径一下，都在classpath下
在applicationContext.xml中定义被引用的bean
<bean id="myDAO" class="com.ryandaigle.persistence.MyDAO" singleton="true" />

说明：
如果不使用WebWork2，完全使用Spring，达到上述效果，在applicationContext.xml中采取类似定义：
<bean id="myAction" class="com.ryandaigle.web.actions.MyAction" singleton="false">
<property name="DAO">
<ref bean="myDAO"/>
</property>
<bean id="myDAO" class="com.ryandaigle.persistence.MyDAO" singleton="true" />

法二：先Spring后WebWork（利用spring-xwork-integration.jar集成）

该方法的执行顺序是先Spring，后WebWork。
即，首先由Spring负责wire所有的依赖关系，再由XWork来执行action。

注意：因为XWork为每个action调用生成一个新的类实例，action在Spring的applicationContext.xml中应该配置为prototype。

1. 配置SpringObjectFactory

(0)下载https://xwork-optional.dev.java.net/files/documents/1475/11992/spring-xwork-integration.jar

(1) 可以在web.xml配置

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<listener>
<listener-class>com.opensymphony.xwork.spring.SpringObjectFactoryListener</listener-class>
</listener>

(2) 或者：在applicationContext.xml配置
<bean id="springObjectFactory"
class="com.opensymphony.xwork.spring.SpringObjectFactory"
init-method="initObjectFactory"/>

以上两种方法任选一种即可

2. 在applicationContext.xml中定义bean
<bean name="some-action" class="fully.qualified.class.name" singleton="false">
<property name="someProperty"><ref bean="someOtherBean"/></property>
</bean>

3. 在xwork.xml中定义action（注意action的class与bean的id相同）

<action name="myAction" class="some-action">
<result name="success">view.jsp</result>
</action>

说明：
该方法与WebWork 2.2中的方法基本相同。

第二部分：WebWork2.2与Spring的集成

Spring是WebWork2.2中唯一支持的IoC容器。

1 配置webwork.properties文件，指定spring作为webwork的IoC容器
webwork.objectFactory = spring
(1)默认的autowiring模式是：by name
即如果applicationContext.xml文件中的bean id与xwork.xml文件中的action name相同，就
(2)如果要改为其他模式：
webwork.objectFactory.spring.autoWire = name|type|auto|constructor

2 配置web.xml文件，启动Spring侦听器
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

3 在WEB-INF目录下增加applicationContext.xml文件
例：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans default-autowire="autodetect">
<bean id="personManager" class="com.acme.PersonManager"/>
...
</beans>

4 设置由Spring来初始化action
4.1     在Spring的applicationContext.xml文件中配置bean（即action类）
4.2     将xwork.xml中的action的class属性，由class名改为Spring中定义的bean名
例如：
(1)applicationContext.xml中，定义bean id是bar
<beans default-autowire="autodetect">
<bean id="bar" class="com.my.BarClass" singleton="false"/>
...
</beans>
(2)xwork.xml中，action的class="bar"，而不是通常的类名
<package name="secure" namespace="/secure" extends="default">
<action name="bar" class="bar">
<result>bar.ftl</result>
</action>
</package>

我将把 java.util.Timer 和 java.util.TimerTask 统称为 Java 计时器框架，它们使程序员可以很容易地计划简单的任务（注意这些类也可用于 J2ME 中）。在 Java 2 SDK, Standard Edition, Version 1.3 中引入这个框架之前，开发人员必须编写自己的调度程序，这需要花费很大精力来处理线程和复杂的 Object.wait() 方法。不过，Java 计时器框架没有足够的能力来满足许多应用程序的计划要求。甚至一项需要在每天同一时间重复执行的任务，也不能直接使用 Timer 来计划，因为在夏令时开始和结束时会出现时间跳跃。

本文展示了一个通用的 Timer 和 TimerTask 计划框架，从而允许更灵活的计划任务。这个框架非常简单 ―― 它包括两个类和一个接口 ―― 并且容易掌握。如果您习惯于使用 Java 定时器框架，那么您应该可以很快地掌握这个计划框架（有关 Java 定时器框架的更多信息，请参阅 参考资料）。

计划单次任务

计划框架建立在 Java 定时器框架类的基础之上。因此，在解释如何使用计划框架以及如何实现它之前，我们将首先看看如何用这些类进行计划。

想像一个煮蛋计时器，在数分钟之后（这时蛋煮好了）它会发出声音提醒您。清单 1 中的代码构成了一个简单的煮蛋计时器的基本结构，它用 Java 语言编写：

package org.tiling.scheduling.examples;
            import java.util.Timer;
            import java.util.TimerTask;
            public class EggTimer {
            private final Timer timer = new Timer();
            private final int minutes;
            public EggTimer(int minutes) {
            this.minutes = minutes;
            }
            public void start() {
            timer.schedule(new TimerTask() {
            public void run() {
            playSound();
            timer.cancel();
            }
            private void playSound() {
            System.out.println("Your egg is ready!");
            // Start a new thread to play a sound...
            }
            }, minutes * 60 * 1000);
            }
            public static void main(String[] args) {
            EggTimer eggTimer = new EggTimer(2);
            eggTimer.start();
            }
            }
            

EggTimer 实例拥有一个 Timer 实例，用于提供必要的计划。用 start() 方法启动煮蛋计时器后，它就计划了一个 TimerTask，在指定的分钟数之后执行。时间到了，Timer 就在后台调用 TimerTask 的 start() 方法，这会使它发出声音。在取消计时器后这个应用程序就会中止。

回页首

计划重复执行的任务

通过指定一个固定的执行频率或者固定的执行时间间隔，Timer 可以对重复执行的任务进行计划。不过，有许多应用程序要求更复杂的计划。例如，每天清晨在同一时间发出叫醒铃声的闹钟不能简单地使用固定的计划频率 86400000 毫秒（24 小时），因为在钟拨快或者拨慢（如果您的时区使用夏令时）的那些天里，叫醒可能过晚或者过早。解决方案是使用日历算法计算每日事件下一次计划发生的时间。而这正是计划框架所支持的。考虑清单 2 中的 AlarmClock 实现（有关计划框架的源代码以及包含这个框架和例子的 JAR 文件，请参阅 参考资料）：

package org.tiling.scheduling.examples;
            import java.text.SimpleDateFormat;
            import java.util.Date;
            import org.tiling.scheduling.Scheduler;
            import org.tiling.scheduling.SchedulerTask;
            import org.tiling.scheduling.examples.iterators.DailyIterator;
            public class AlarmClock {
            private final Scheduler scheduler = new Scheduler();
            private final SimpleDateFormat dateFormat =
            new SimpleDateFormat("dd MMM yyyy HH:mm:ss.SSS");
            private final int hourOfDay, minute, second;
            public AlarmClock(int hourOfDay, int minute, int second) {
            this.hourOfDay = hourOfDay;
            this.minute = minute;
            this.second = second;
            }
            public void start() {
            scheduler.schedule(new SchedulerTask() {
            public void run() {
            soundAlarm();
            }
            private void soundAlarm() {
            System.out.println("Wake up! " +
            "It's " + dateFormat.format(new Date()));
            // Start a new thread to sound an alarm...
            }
            }, new DailyIterator(hourOfDay, minute, second));
            }
            public static void main(String[] args) {
            AlarmClock alarmClock = new AlarmClock(7, 0, 0);
            alarmClock.start();
            }
            }
            

注意这段代码与煮蛋计时器应用程序非常相似。AlarmClock 实例拥有一个 Scheduler （而不是 Timer）实例，用于提供必要的计划。启动后，这个闹钟对 SchedulerTask （而不是 TimerTask）进行调度用以发出报警声。这个闹钟不是计划一个任务在固定的延迟时间后执行，而是用 DailyIterator 类描述其计划。在这里，它只是计划任务在每天上午 7:00 执行。下面是一个正常运行情况下的输出：

Wake up! It's 24 Aug 2003 07:00:00.023
            Wake up! It's 25 Aug 2003 07:00:00.001
            Wake up! It's 26 Aug 2003 07:00:00.058
            Wake up! It's 27 Aug 2003 07:00:00.015
            Wake up! It's 28 Aug 2003 07:00:00.002
            ...
            

DailyIterator 实现了 ScheduleIterator，这是一个将 SchedulerTask 的计划执行时间指定为一系列 java.util.Date 对象的接口。然后 next() 方法按时间先后顺序迭代 Date 对象。返回值 null 会使任务取消（即它再也不会运行）―― 这样的话，试图再次计划将会抛出一个异常。清单 3 包含 ScheduleIterator 接口：

package org.tiling.scheduling;
            import java.util.Date;
            public interface ScheduleIterator {
            public Date next();
            }
            

DailyIterator 的 next() 方法返回表示每天同一时间（上午 7:00）的 Date 对象，如清单 4 所示。所以，如果对新构建的 next() 类调用 next()，那么将会得到传递给构造函数的那个日期当天或者后面一天的 7:00 AM。再次调用 next() 会返回后一天的 7:00 AM，如此重复。为了实现这种行为，DailyIterator 使用了 java.util.Calendar 实例。构造函数会在日历中加上一天，对日历的这种设置使得第一次调用 next() 会返回正确的 Date。注意代码没有明确地提到夏令时修正，因为 Calendar 实现（在本例中是 GregorianCalendar）负责对此进行处理，所以不需要这样做。

package org.tiling.scheduling.examples.iterators;
            import org.tiling.scheduling.ScheduleIterator;
            import java.util.Calendar;
            import java.util.Date;
            /**
            * A DailyIterator class returns a sequence of dates on subsequent days
            * representing the same time each day.
            */
            public class DailyIterator implements ScheduleIterator {
            private final int hourOfDay, minute, second;
            private final Calendar calendar = Calendar.getInstance();
            public DailyIterator(int hourOfDay, int minute, int second) {
            this(hourOfDay, minute, second, new Date());
            }
            public DailyIterator(int hourOfDay, int minute, int second, Date date) {
            this.hourOfDay = hourOfDay;
            this.minute = minute;
            this.second = second;
            calendar.setTime(date);
            calendar.set(Calendar.HOUR_OF_DAY, hourOfDay);
            calendar.set(Calendar.MINUTE, minute);
            calendar.set(Calendar.SECOND, second);
            calendar.set(Calendar.MILLISECOND, 0);
            if (!calendar.getTime().before(date)) {
            calendar.add(Calendar.DATE, -1);
            }
            }
            public Date next() {
            calendar.add(Calendar.DATE, 1);
            return calendar.getTime();
            }
            }
            

回页首

实现计划框架

在上一节，我们学习了如何使用计划框架，并将它与 Java 定时器框架进行了比较。下面，我将向您展示如何实现这个框架。除了 清单 3 中展示的 ScheduleIterator 接口，构成这个框架的还有另外两个类 ―― Scheduler 和 SchedulerTask 。这些类实际上在内部使用 Timer 和 SchedulerTask，因为计划其实就是一系列的单次定时器。清单 5 和 6 显示了这两个类的源代码：

package org.tiling.scheduling;
            import java.util.Date;
            import java.util.Timer;
            import java.util.TimerTask;
            public class Scheduler {
            class SchedulerTimerTask extends TimerTask {
            private SchedulerTask schedulerTask;
            private ScheduleIterator iterator;
            public SchedulerTimerTask(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {
            this.schedulerTask = schedulerTask;
            this.iterator = iterator;
            }
            public void run() {
            schedulerTask.run();
            reschedule(schedulerTask, iterator);
            }
            }
            private final Timer timer = new Timer();
            public Scheduler() {
            }
            public void cancel() {
            timer.cancel();
            }
            public void schedule(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {
            Date time = iterator.next();
            if (time == null) {
            schedulerTask.cancel();
            } else {
            synchronized(schedulerTask.lock) {
            if (schedulerTask.state != SchedulerTask.VIRGIN) {
            throw new IllegalStateException("Task already
            scheduled " + "or cancelled");
            }
            schedulerTask.state = SchedulerTask.SCHEDULED;
            schedulerTask.timerTask =
            new SchedulerTimerTask(schedulerTask, iterator);
            timer.schedule(schedulerTask.timerTask, time);
            }
            }
            }
            private void reschedule(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {
            Date time = iterator.next();
            if (time == null) {
            schedulerTask.cancel();
            } else {
            synchronized(schedulerTask.lock) {
            if (schedulerTask.state != SchedulerTask.CANCELLED) {
            schedulerTask.timerTask =
            new SchedulerTimerTask(schedulerTask, iterator);
            timer.schedule(schedulerTask.timerTask, time);
            }
            }
            }
            }
            }
            

清单 6 显示了 SchedulerTask 类的源代码：

package org.tiling.scheduling;
            import java.util.TimerTask;
            public abstract class SchedulerTask implements Runnable {
            final Object lock = new Object();
            int state = VIRGIN;
            static final int VIRGIN = 0;
            static final int SCHEDULED = 1;
            static final int CANCELLED = 2;
            TimerTask timerTask;
            protected SchedulerTask() {
            }
            public abstract void run();
            public boolean cancel() {
            synchronized(lock) {
            if (timerTask != null) {
            timerTask.cancel();
            }
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
            }
            }
            public long scheduledExecutionTime() {
            synchronized(lock) {
            return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
            }
            }
            }
            

就像煮蛋计时器，Scheduler 的每一个实例都拥有 Timer 的一个实例，用于提供底层计划。Scheduler 并没有像实现煮蛋计时器时那样使用一个单次定时器，它将一组单次定时器串接在一起，以便在由 ScheduleIterator 指定的各个时间执行 SchedulerTask 类。

考虑 Scheduler 上的 public schedule() 方法 ―― 这是计划的入口点，因为它是客户调用的方法（在 取消任务 一节中将描述仅有的另一个 public 方法 cancel()）。通过调用 ScheduleIterator 接口的 next()，发现第一次执行 SchedulerTask 的时间。然后通过调用底层 Timer 类的单次 schedule() 方法，启动计划在这一时刻执行。为单次执行提供的 TimerTask 对象是嵌入的 SchedulerTimerTask 类的一个实例，它包装了任务和迭代器（iterator）。在指定的时间，调用嵌入类的 run() 方法，它使用包装的任务和迭代器引用以便重新计划任务的下一次执行。reschedule() 方法与 schedule() 方法非常相似，只不过它是 private 的，并且执行一组稍有不同的 SchedulerTask 状态检查。重新计划过程反复重复，为每次计划执行构造一个新的嵌入类实例，直到任务或者调度程序被取消（或者 JVM 关闭）。

类似于 TimerTask，SchedulerTask 在其生命周期中要经历一系列的状态。创建后，它处于 VIRGIN 状态，这表明它从没有计划过。计划以后，它就变为 SCHEDULED 状态，再用下面描述的方法之一取消任务后，它就变为 CANCELLED 状态。管理正确的状态转变 ―― 如保证不对一个非 VIRGIN 状态的任务进行两次计划 ―― 增加了 Scheduler 和 SchedulerTask 类的复杂性。在进行可能改变任务状态的操作时，代码必须同步任务的锁对象。

取消任务

取消计划任务有三种方式。第一种是调用 SchedulerTask 的 cancel() 方法。这很像调用 TimerTask 的 cancel()方法：任务再也不会运行了，不过已经运行的任务仍会运行完成。 cancel() 方法的返回值是一个布尔值，表示如果没有调用 cancel() 的话，计划的任务是否还会运行。更准确地说，如果任务在调用 cancel() 之前是 SCHEDULED 状态，那么它就返回 true。如果试图再次计划一个取消的（甚至是已计划的）任务，那么 Scheduler 就会抛出一个 IllegalStateException。

取消计划任务的第二种方式是让 ScheduleIterator 返回 null。这只是第一种方式的简化操作，因为 Scheduler 类调用 SchedulerTask 类的 cancel()方法。如果您想用迭代器而不是任务来控制计划停止时间时，就用得上这种取消任务的方式了。

第三种方式是通过调用其 cancel() 方法取消整个 Scheduler。这会取消调试程序的所有任务，并使它不能再计划任何任务。

回页首

扩展 cron 实用程序

可以将计划框架比作 UNIX 的 cron 实用程序，只不过计划次数的规定是强制性而不是声明性的。例如，在 AlarmClock 实现中使用的 DailyIterator 类，它的计划与 cron 作业的计划相同，都是由以 0 7 * * * 开始的 crontab 项指定的（这些字段分别指定分钟、小时、日、月和星期）。

不过，计划框架比 cron 更灵活。想像一个在早晨打开热水的 HeatingController 应用程序。我想指示它“在每个工作日上午 8:00 打开热水，在周未上午 9:00 打开热水”。使用 cron，我需要两个 crontab 项（0 8 * * 1,2,3,4,5 和 0 9 * * 6,7）。而使用 ScheduleIterator 的解决方案更简洁一些，因为我可以使用复合（composition）来定义单一迭代器。清单 7 显示了其中的一种方法：

    int[] weekdays = new int[] {
            Calendar.MONDAY,
            Calendar.TUESDAY,
            Calendar.WEDNESDAY,
            Calendar.THURSDAY,
            Calendar.FRIDAY
            };
            int[] weekend = new int[] {
            Calendar.SATURDAY,
            Calendar.SUNDAY
            };
            ScheduleIterator i = new CompositeIterator(
            new ScheduleIterator[] {
            new RestrictedDailyIterator(8, 0, 0, weekdays),
            new RestrictedDailyIterator(9, 0, 0, weekend)
            }
            );
            

RestrictedDailyIterator 类很像 DailyIterator，只不过它限制为只在一周的特定日子里运行，而一个 CompositeIterator 类取得一组 ScheduleIterators，并将日期正确排列到单个计划中。这些类的源代码请参阅 参考资料。

有许多计划是 cron 无法生成的，但是 ScheduleIterator 实现却可以。例如，“每个月的最后一天”描述的计划可以用标准 Java 日历算法来实现（用 Calendar 类），而用 cron 则无法表达它。应用程序甚至无需使用 Calendar 类。在本文的源代码（请参阅 参考资料）中，我加入了一个安全灯控制器的例子，它按“在日落之前 15 分钟开灯”这一计划运行。这个实现使用了 Calendrical Calculations Software Package （请参阅 参考资料），用于计算当地（给定经度和纬度）的日落时间。

回页首

实时保证

在编写使用计划的应用程序时，一定要了解框架在时间方面有什么保证。我的任务是提前还是延迟执行？如果有提前或者延迟，偏差最大值是多少？不幸的是，对这些问题没有简单的答案。不过在实际中，它的行为对于很多应用程序已经足够了。下面的讨论假设系统时钟是正确的（有关网络时间协议(Network Time Protocol)的信息，请参阅 参考资料）。

因为 Scheduler 将计划委托给 Timer 类，Scheduler 可以做出的实时保证与 Timer 的一样。Timer 用 Object.wait(long) 方法计划任务。当前线程要等待直到唤醒它，唤醒可能出于以下原因之一：

1. 另一个线程调用对象的 notify() 或者 notifyAll() 方法。
2. 线程被另一个线程中断。
3. 在没有通知的情况下，线程被唤醒（称为 spurious wakeup，Joshua Bloch 的 Effective Java Programming Language Guide 一书中 Item 50 对其进行了描述 ―― 请参阅 参考资料）。
4. 规定的时间已到。

对于 Timer 类来说，第一种可能性是不会发生的，因为对其调用 wait() 的对象是私有的。即便如此，Timer 实现仍然针对前三种提前唤醒的原因进行了保护，这样保证了线程在规定时间后才唤醒。目前，Object.wait(long) 的文档注释声明，它会在规定的时间“前后”苏醒，所以线程有可能提前唤醒。在本例中，Timer 会让另一个 wait() 执行（scheduledExecutionTime - System.currentTimeMillis()）毫秒，从而保证任务永远不会提前执行。

任务是否会延迟执行呢？会的。延迟执行有两个主要原因：线程计划和垃圾收集。

Java 语言规范故意没有对线程计划做严格的规定。这是因为 Java 平台是通用的，并针对于大范围的硬件及其相关的操作系统。虽然大多数 JVM 实现都有公平的线程调度程序，但是这一点没有任何保证 —— 当然，各个实现都有不同的为线程分配处理器时间的策略。因此，当 Timer 线程在分配的时间后唤醒时，它实际执行其任务的时间取决于 JVM 的线程计划策略，以及有多少其他线程竞争处理器时间。因此，要减缓任务的延迟执行，应该将应用程序中可运行的线程数降至最少。为了做到这一点，可以考虑在一个单独的 JVM 中运行调度程序。

对于创建大量对象的大型应用程序，JVM 花在垃圾收集（GC）上的时间会非常多。默认情况下，进行 GC 时，整个应用程序都必须等待它完成，这可能要有几秒钟甚至更长的时间（Java 应用程序启动器的命令行选项 -verbose:gc 将导致向控制台报告每一次 GC 事件）。要将这些由 GC 引起的暂停（这可能会影响快速任务的执行）降至最少，应该将应用程序创建的对象的数目降至最低。同样，在单独的 JVM 中运行计划代码是有帮助的。同时，可以试用几个微调选项以尽可能地减少 GC 暂停。例如，增量 GC 会尽量将主收集的代价分散到几个小的收集上。当然这会降低 GC 的效率，但是这可能是时间计划的一个可接受的代价（有关 GC 微调的更多提示，请参阅 参考资料）。

我被计划到什么时候？

如果任务本身能监视并记录所有延迟执行的实例，那么对于确定任务是否能按时运行会很有帮助。SchedulerTask 类似于 TimerTask，有一个 scheduledExecutionTime() 方法，它返回计划任务最近一次执行的时间。在任务的 run() 方法开始时，对表达式 System.currentTimeMillis() - scheduledExecutionTime() 进行判断，可以让您确定任务延迟了多久执行（以毫秒为单位）。可以记录这个值，以便生成一个关于延迟执行的分布统计。可以用这个值决定任务应当采取什么动作 ―― 例如，如果任务太迟了，那么它可能什么也不做。在遵循上述原则的情况下，如果应用程序需要更严格的时间保证，可参考 Java 的实时规范（更多信息请参阅 参考资料）。

回页首

结束语

在本文中，我介绍了 Java 定时器框架的一个简单增强，它使得灵活的计划策略成为可能。新的框架实质上是更通用的 cron ―― 事实上，将 cron 实现为一个 ScheduleIterator 接口，用以替换单纯的 Java cron，这是非常有用的。虽然没有提供严格的实时保证，但是许多需要计划定期任务的通用 Java 应用程序都可以使用这一框架。

问题提出

在作者所从事的项目中，要开发一个应用服务器，实现如下所述的功能：能够高效的处理来自多个客户端的并发请求。为了简化同步控制，分离并发逻辑和业务逻辑，我们采用了Active Object模式，具体的实现可以参见作者的另外一篇文章：《构建Java并发模型框架》（ http://www.ibm.com/developerworks/cn/java/l-multithreading/index.shtml）。该设计中有一个核心部件ActiveQueue用于存放客户的请求。为了能够做到应用服务器的负载控制，我们对于ActiveQueue的大小进行了限制，如果当前的客户请求数量已经达到这个限制，就让后继的请求等待，具体的代码实现片断如下（为了简洁起见，省略了其他无关的代码）：

		class ActiveQueue {
            ...
            public synchronized void enqueue(ClientRequest cr) throws InterruptedException
            {
            while(isFull( ) ){  // ActiveQueue的大小达到上限
            wait();
            }
            // 把用户请求添加到处理队列中
            notifyAll();
            }
            ...
            }
            

该方法刚开始工作的很好，但是随着项目开发的进展，在随后的测试中我们发现了两个较为严重的问题：1、当并发请求的客户端很多时，会造成某些客户端等待的时间过长，对于客户端的使用者来说非常不友好；2、由于系统中应用服务器的其他方面的异常同样会造成客户端请求的永久等待比如：应用服务器在处理完客户端请求后，由于异常没有正确的调用相应notify方法。所以为了改善程序的用户友好性以及健壮性，我们决定采用带有超时语意的wait方法。该方法的原型声明如下：

	public final void wait (long millisecTimeout)  throws InterruptedException;
            使用该方法改进后的代码实现片断如下：
            class ActiveQueue {
            ...
            public synchronized void enqueue(ClientRequest cr, long timeout)
            throws InterruptedException
            {
            while(isFull( ) ){  // ActiveQueue的大小达到上限
            wait(timeout);
            // 语意模糊性体现于此，当wait返回时
            // 我们无法区分是由于notify的通知还是超时触发的
            // 因此我们无法做出适当的处理
            }
            // 把用户请求添加到处理队列中
            notifyAll();
            }
            ...
            }
            

可以看出，简单的使用一个具有超时语意的wait方法是不可行的，原因就在于wait方法超时语意的模糊性。在下面的小节会先给出一个初步的解决方案，随后我们将使用模式对于该方案进行重构从而构造出一个比较通用的方案。

回页首

初步解决方案

我们的初步解决方案采用了Doug Lea（Doug Lea为对象并发领域世界级的专家）给出的一个显式的判断算法（关于该算法更加详细、深入的论述请参考参考文献〔1〕），通过该算法来辨别是否已经超时。采用该算法的解决方案的代码实现片断如下：

	class ActiveQueue {
            ...
            public synchronized void enqueue(ClientRequest cr, long timeout)
            throws InterruptedException, TimeoutException
            {
            if (isFull ()) {  // 判断队列是否为满
            long start = System.currentTimeMillis ();
            long waitTime = timeout;
            for (;;) {         // 一直等待到队列不满被notify通知或者超时
            wait (waitTime);
            if (isFull ()) { //重新判断队列是否为满
            long now = System.currentTimeMillis ();
            long timeSoFar = now - start;    // 队列仍然为满，计算已经等待的时间
            if (timeSoFar >= msecTimeout)  // 如果超时，抛出TimeoutException异常
            throw new TimeoutException ();
            else  // 没有超时，计算还要等待的时间
            waitTime = timeout - timeSoFar;
            }
            else  // 被notify唤醒，并且队列不为满
            break;
            }
            }
            // 把用户请求添加到处理队列中
            notifyAll();
            }
            ...
            }
            

可以看出，这个算法非常的简单，核心思路就是在每次wait返回时，计算wait等待的时间，并比较该时间和设定的要等待的时间，如果大于设定的要等待的时间，即确定为超时，否则确定为被notify唤醒。

回页首

使解决方案一般化

上述的解决方案针对我们目前的要求已经可以很好的工作了，但是细心的读者一定会发现在上面给出的解决方案中我们把两个无关的概念揉合在了一起：队列是否为满的判断逻辑和是否超时的计算判断逻辑。为什么说这是两个无关的概念呢？因为队列是否为满是与我们开发的具体应用相关的，不同的应用会有不同类型的判断逻辑（比如：不使用队列的应用可能会有其他在概念上类似的判断逻辑），而计算判断超时的逻辑是和具体应用无关的。如果我们能够把这两个概念剥离开来，那么这二者就可以独立变化，我们的解决方案的可重用性就会增强。

我们使用Template Method模式（参见参考文献〔2〕）来指导我们的重构。首先，我们会根据和具体应用无关的超时计算判断的算法定义一个通用的算法框架，把和具体应用逻辑相关的条件判断作为一个抽象的hook方法，延迟到具体的应用中去实现，从而实现了和应用无关的超时计算判断逻辑的复用。实现该算法的抽象基类的关键实现代码如下：

		public abstract class WaitWithTiming
            {
            // wait方法要作用的对象，对于上述例子就是ActiveQueue
            protected Object object_;
            public WaitWithTiming (Object obj)
            {
            object_ = obj;
            }
            // 这是一个抽象的hook方法，由具体的应用实现，该方法由本算法框架调用
            public abstract boolean condition ();
            // 计算判断超时的算法框架实现
            public final void timedWait (long timeout)
            throws InterruptedException, TimeoutException
            {
            if (condition ()) {  //调用具体应用实现的hook方法
            long start = System.currentTimeMillis ();
            long waitTime = msecTimeout;
            for (;;) {
            object_.wait (waitTime);
            if (condition ()) {
            long now = System.currentTimeMillis ();
            long timeSoFar = now - start;
            if (timeSoFar >= msecTimeout)
            throw new TimeoutException ();
            else
            waitTime = timeout - timeSoFar;
            }
            else
            break;
            }
            }
            }
            public final void announce() {
            object_.notifyAll ();
            }
            }
            

回页首

使用方法介绍

本小节我们将对上一节给出的抽象基类WaitWithTiming的使用方法进行详细的介绍。我们当然可以直接使得ActiveQueue继承自WaitWithTiming，并实现相应的抽象hook方法condition，但是这样做有一个弊端，就是对于ActiveQueue我们只能够实现仅仅一个condition，如果我们要添加针对dequeue时队列为空的条件判断逻辑就无能为力了，因为WaitWithWaiting仅仅只有一个condition方法（其实，即使有多个也没有办法做到通用，因为不能对具体的应用的需求进行假设）。

我们推荐的使用方法是，根据具体应用的需求，整理出需要的判断条件，创建相应的类来表示这些判断条件，使这些用来表示具体判断条件的类继承自WaitWithTiming，这些类中具体的条件判断逻辑的实现可以使用相应的具体的应用实体。比如：对于本文开始所列举的应用，我们需要的判断条件为队列为满，所以我们可以定义一个QueueFullCondition类继承自WaitWithTiming，在QueueFullCondition中实现抽象的hook方法condition的逻辑，在该逻辑中在使用ActiveQueue的isFull方法。使用这种委托的方法，我们就可以比较有效的解决一个对象同时需要多个判断条件的问题（不同的判断条件只需定义不同的子类即可）。相应的UML结构图和关键代码实现如下：

UML结构图：

关键代码片断：

class QueueFullCondition extends WaitWithTiming
            {
            public QueueFullCondition (ActiveQueue aq)
            { super (aq); }  // 为WaitWithTiming中的object_赋值
            public boolean condition () {
            ActiveQueue aq = (ActiveQueue) object_; //使用ActiveQueue来实现具体的判断逻辑
            return aq.isFull ();
            }
            }
            class ActiveQueue {
            ...
            public synchronized void enqueue(ClientRequest cr, long timeout)
            throws InterruptedException, TimeoutException
            {
            //具有时限控制的等待
            queueFullCondition_.timedWait (timeout);
            // 把用户请求添加进队列
            //唤醒等待在ActiveQueue上的线程
            queueFullCondition_.announce ();
            }
            ...
            private QueueFullCondition queueFullCondition_  =  new QueueFullCondition (this);
            }
            

回页首

要注意的问题

如果读者朋友仔细观察的话，就会觉察到在WaitWithTiming类中的timedWait方法的定义中没有添加synchronized关键字，这一点是非常关键的，因为是为了避免在编写并发的Java应用时一个常见的死锁问题：嵌套的monitor。下面对于这个问题进行简单的介绍，关于这一问题更为详细的论述请参见参考文献〔1〕。

什么是嵌套的monitor问题呢？嵌套的monitor是指：当一个线程获得了对象A的monitor锁，接着又获得了对象B的monitor锁，在还没有释放对象B的monitor锁时，调用了对象B的wait方法，此时，该线程释放对象B的monitor锁并等待在对象B的线程等待队列上，但是此时该线程还拥有对象A的monitor锁。如果该线程的唤起条件依赖于另一个线程首先要获得对象A的monitor锁的话，就会引起死锁，因为此时别的线程无法获得上述线程还没有释放的对象A的monitor锁，结果就出现了死锁情况。一般的解决方案是：在设计时线程不要获取对象B的monitor锁，而仅仅使用对象A的monitor锁。

针对我们前面列举的例子，ActiveQueu可以类比为对象A，queueFullContion_可以类比为对象B，如果我们在timedWait方法前面添加上synchronized关键字，就有可能会发生上述的死锁情况，因为当我们在调用ActiveQueu的enqueue方法中调用了queueFullContion_的timedWait方法后，如果队列为满，虽然我们释放了queueFullContion_的monitor锁，但是我们还持有ActiveQueue的monitor锁，并且我们的唤醒条件依赖于另外一个线程调用ActivcQueue的dequeue方法，但是因为此时我们没有释放ActiveQueue的monitor锁，所以另外的线程就无法调用ActiveQueu的dequeue方法，那么结果就是这两个线程就都只能够等待。

回页首

总结

本文对于Java中wait方法超时语意的模糊性进行了分析，并给出了一个比较通用的解决方案，本解决方案对于需要精确的超时语意的应用还是无法很好的适用的，因为方案中所给出的关于超时计算的算法是不精确的。还有一点就是有关嵌套monitor的问题，在编写多线程的Java程序时一定要特别注意，否则非常容易引起死锁。其实，本文所讲述的所有问题的根源都是由于Java对于wait方法超时语意实现的模糊性造成的，如果在后续的Java版本中对此进行了修正，那么本文给出的解决方案就是多余的了。

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。正是由于这个特点，单例对象通常作为程序中的存放配置信息的载体，因为它能保证其他对象读到一致的信息。例如在某个服务器程序中，该服务器的配置信息可能存放在数据库或文件中，这些配置数据由某个单例对象统一读取，服务进程中的其他对象如果要获取这些配置信息，只需访问该单例对象即可。这种方式极大地简化了在复杂环境下，尤其是多线程环境下的配置管理，但是随着应用场景的不同，也可能带来一些同步问题。

本文将探讨一下在多线程环境下，使用单例对象作配置信息管理时可能会带来的几个同步问题，并针对每个问题给出可选的解决办法。

问题描述

在多线程环境下，单例对象的同步问题主要体现在两个方面，单例对象的初始化和单例对象的属性更新。

本文描述的方法有如下假设：

1. 单例对象的属性（或成员变量）的获取，是通过单例对象的初始化实现的。也就是说，在单例对象初始化时，会从文件或数据库中读取最新的配置信息。
2. 其他对象不能直接改变单例对象的属性，单例对象属性的变化来源于配置文件或配置数据库数据的变化。

1.1 单例对象的初始化

首先，讨论一下单例对象的初始化同步。单例模式的通常处理方式是，在对象中有一个静态成员变量，其类型就是单例类型本身；如果该变量为null，则创建该单例类型的对象，并将该变量指向这个对象；如果该变量不为null，则直接使用该变量。

其过程如下面代码所示：

  public class GlobalConfig {
            private static GlobalConfig instance = null;
            private Vector properties = null;
            private GlobalConfig() {
            //Load configuration information from DB or file
            //Set values for properties
            }
            public static GlobalConfig getInstance() {
            if (instance == null) {
            instance = new GlobalConfig();
            }
            return instance;
            }
            public Vector getProperties() {
            return properties;
            }
            }
            

这种处理方式在单线程的模式下可以很好的运行；但是在多线程模式下，可能产生问题。如果第一个线程发现成员变量为null，准备创建对象；这是第二个线程同时也发现成员变量为null，也会创建新对象。这就会造成在一个JVM中有多个单例类型的实例。如果这个单例类型的成员变量在运行过程中变化，会造成多个单例类型实例的不一致，产生一些很奇怪的现象。例如，某服务进程通过检查单例对象的某个属性来停止多个线程服务，如果存在多个单例对象的实例，就会造成部分线程服务停止，部分线程服务不能停止的情况。

1.2 单例对象的属性更新

通常，为了实现配置信息的实时更新，会有一个线程不停检测配置文件或配置数据库的内容，一旦发现变化，就更新到单例对象的属性中。在更新这些信息的时候，很可能还会有其他线程正在读取这些信息，造成意想不到的后果。还是以通过单例对象属性停止线程服务为例，如果更新属性时读写不同步，可能访问该属性时这个属性正好为空（null），程序就会抛出异常。

回页首

解决方法

2.1 单例对象的初始化同步

对于初始化的同步，可以通过如下代码所采用的方式解决。

  public class GlobalConfig {
            private static GlobalConfig instance = null;
            private Vector properties = null;
            private GlobalConfig() {
            //Load configuration information from DB or file
            //Set values for properties
            }
            private static synchronized void syncInit() {
            if (instance == null) {
            instance = new GlobalConfig();
            }
            }
            public static GlobalConfig getInstance() {
            if (instance == null) {
            syncInit();
            }
            return instance;
            }
            public Vector getProperties() {
            return properties;
            }
            }
            

这种处理方式虽然引入了同步代码，但是因为这段同步代码只会在最开始的时候执行一次或多次，所以对整个系统的性能不会有影响。

2.2 单例对象的属性更新同步

为了解决第2个问题，有两种方法：

1，参照读者/写者的处理方式

设置一个读计数器，每次读取配置信息前，将计数器加1，读完后将计数器减1。只有在读计数器为0时，才能更新数据，同时要阻塞所有读属性的调用。代码如下。

  public class GlobalConfig {
            private static GlobalConfig instance;
            private Vector properties = null;
            private boolean isUpdating = false;
            private int readCount = 0;
            private GlobalConfig() {
            //Load configuration information from DB or file
            //Set values for properties
            }
            private static synchronized void syncInit() {
            if (instance == null) {
            instance = new GlobalConfig();
            }
            }
            public static GlobalConfig getInstance() {
            if (instance==null) {
            syncInit();
            }
            return instance;
            }
            public synchronized void update(String p_data) {
            syncUpdateIn();
            //Update properties
            }
            private synchronized void syncUpdateIn() {
            while (readCount > 0) {
            try {
            wait();
            } catch (Exception e) {
            }
            }
            }
            private synchronized void syncReadIn() {
            readCount++;
            }
            private synchronized void syncReadOut() {
            readCount--;
            notifyAll();
            }
            public Vector getProperties() {
            syncReadIn();
            //Process data
            syncReadOut();
            return properties;
            }
            }
            

2，采用"影子实例"的办法

具体说，就是在更新属性时，直接生成另一个单例对象实例，这个新生成的单例对象实例将从数据库或文件中读取最新的配置信息；然后将这些配置信息直接赋值给旧单例对象的属性。如下面代码所示。

  public class GlobalConfig {
            private static GlobalConfig instance = null;
            private Vector properties = null;
            private GlobalConfig() {
            //Load configuration information from DB or file
            //Set values for properties
            }
            private static synchronized void syncInit() {
            if (instance = null) {
            instance = new GlobalConfig();
            }
            }
            public static GlobalConfig getInstance() {
            if (instance = null) {
            syncInit();
            }
            return instance;
            }
            public Vector getProperties() {
            return properties;
            }
            public void updateProperties() {
            //Load updated configuration information by new a GlobalConfig object
            GlobalConfig shadow = new GlobalConfig();
            properties = shadow.getProperties();
            }
            }
            

注意：在更新方法中，通过生成新的GlobalConfig的实例，从文件或数据库中得到最新配置信息，并存放到properties属性中。

上面两个方法比较起来，第二个方法更好，首先，编程更简单；其次，没有那么多的同步操作，对性能的影响也不大。

概要

时至今日，SOAP (Simple Object Access Protocol)已由最初的实验性协议，走进了现实应用中。但是，当在分布式Java应用程序中引入SOAP作为底层通讯协议时，它所带来的繁重的网络开销成为令人头痛的问题。本文将通过设计和实现一个网上商品查询系统，来展示如何利用缓冲管理、业务代理等设计模式加速Web服务的调用效率。

回页首

引子

众所周知，Web服务的革命早已开始。SOAP(简单对象访问协议)，一种XML RPC消息协议成为了Web服务的底层通信协议。从它的名字就可以知道，它是一种易于定义、易于使用的轻量级协议。SOAP使发送和接收XML，并把它转化为异构语言对象变得容易。

但是，在拥有易用性和灵活性的同时也是要付出效率上的代价的。协议的设计者把效率方面的复杂性留给了应用程序开发者。一个简单的SOAP实现往往会给企业级应用程序带来无状态、运行效率低下等大量的问题。大数据量，频繁的SOAP调用甚至可能会引起网络阻塞。

解决Web服务效率问题的方法，一般分为两个层次：

1. 容器层。Java Web服务的服务端一般都是一个Servlet应用程序，我们所说的容器层就是指运行Servlet的Web Server。例如，Apache Axis的服务端就可以运行在Tomcat这个Web Server上。
2. 应用程序层。一般是指用户自己编写的代码。这里可以是客户端的代码，也可以是服务器端提供Web服务的代码。解决的方法，一般包括缓冲数据、压缩信息量等等。

下文将会介绍一种基于应用程序层的解决方案。通过缓冲模式，代理模式构造一个对商业逻辑透明的，提高Web服务效率的解决方案。本解决方案同时还支持自动同步缓冲区信息和UI自动更新。

在这里假设读者对SOAP已有一定的认识，并且懂得如何使用Apache Axis创建、发布Web服务。本文将不会描述SOAP的工作原理，但是会提供相关链接，在那里可以得到更多的信息。

回页首

Web Service在应用程序中的问题

当开发基于SOAP通信协议的胖客户端Java应用程序时，必须注意三个问题：性能、性能、还是性能。如果客户端程序会经常的访问服务端的相同信息，然而实现方法采取每次访问都要进行Web服务的调用，这样效率肯定很低。但现实是成百上千的客户端应用程序会为了这相同数据同时访问服务器，并且它们的操作仅仅限于浏览，服务器性能下降的会更加明显，甚至瘫痪。初步估计，一次SOAP调用的代价与执行一次关系型数据库的SQL操作相当甚至更大(如果考虑到网络的因素)。如下图：

但是，事实上，通常一个SOAP调用总是伴随着一次SQL操作。所以，一个现实中的SOAP调用的代价包括：网络的延时、Server端CPU操作SOAP的时间和数据库服务器的SQL操作延时。

由上图可见，一次Web服务调用如果不考虑网络的因素，就已经需要将近两倍于数据库SQL操作的时间。这样的效率是肯定无法接受的。因此，有一种解决方法就是尽量减少进行Web服务调用的次数了。正统的解决方案，就是采取缓冲机制。其中，缓冲机制还可以分为3种：在Server端缓冲，在Client端缓冲和不缓冲（有些实际应用中，数据量很小。维护缓冲区比不维护的代价更大）。下文中的例子程序将会根据缓冲管理模式，设计一个简单的应用程序。

回页首

具体问题举例 —— 网上商品价格查询系统

回页首

简介

这是一个常见的程序，在很多的WebService开发包中，都有类似的例子。如Apache Axis、IBM的ETTK等。本例子，仅仅包括一个提供商品报价的服务类，它只提供了一些很简单的操作，如增加和删除商品信息，获取商品信息等等方法。通过WSDL描述这些操作，并且暴露给用户，使其可以方便的开发自己的客户端程序。本程序有一个特点，支持自动同步数据，准确的说应该是自动同步缓冲区数据。事实上，缓冲技术和自动同步技术并没有任何关系，可以分开使用。最后，本程序还提供了一个简单的GUI客户端程序，可以执行部分Web服务方法。

回页首

整体架构

客户端架构

通过代理模式，很好的分离了GUI层和业务层逻辑。又利用监听器模式实现了透明的缓冲机制。该实例程序客户端包括两个主面板（panel）。上方面版（panel）显示所有可用的商品信息，而下方面板让用户可以添加和更新商品的信息。当客户端开始运行，它会利用线程阻塞机制在服务端注册一个数据变更监听器，监听所有的数据更新事件。然后，调用Get All Quotes 服务获取所有的商品信息。当任意一个客户机提交和更新了数据，该客户端的监视线程就会返回，于是一次SOAP调用结束。这同时使到服务器端的数据改变事件被触发，从而主动激活所有被阻塞的客户端监视线程，并且触发它们的缓冲区数据更新的SOAP调用，然后每个客户端又会在服务器端注册新的数据改变监视线程，如此反复。这样，只有更新数据的时候，才会发送SOAP调用，一般的读数据实际上是读缓冲区内的数据，而不会进行代价颇高的Web服务调用，从而提高了速度，又实现了数据自动同步功能。

服务器端架构

在服务端设计中，充分利用接口（Interface）带来的便利。全部用接口来描述功能，彻底的隐藏了具体实现细节。下面介绍，Web服务端设计的小技巧：

根据接口（Interface）来产生你的WSDL文件

之所以要这样做，主要有两个原因：

1. 将接口发布为Web服务可以避免将一些不需要的方法发布为Web服务。例如main(String [ ] args)
2. 对接口编程可以保证灵活性。你可以提供不同的服务实现类，并且无缝的切换。

Apache Axis为此提供了方便的工具（Java2WSDL、 WSDL2Java），可以通过这些工具迅速的产生整个服务端架构。下面是整个Server端的类关系图。

下面列出了整个演示程序所有的包以及每个包的重要组成类。

demo.productinfo.clientside

• ClientNotificationHandler：

  客户端数据同步处理器。用于处理本地缓冲类实例。其包含一个内部线程类，用于实现客户端的线程阻塞。

demo.productinfo.clientside.businessdelegates

• DataChangeListener： 定义数据改变监听器的行为。
• NotificationServiceDelegate： 调用Web服务的代理类。
• ProductInfoServiceDelegate： 用于调用Web服务的代理类。

demo.productinfo.clientside.cache

• CacheExpiredListener：定义了缓冲过期监听器的行为。
• SimpleCache： 简单缓冲模式的实现类。

demo.productinfo.clientside.soapstub
这个包里面的所有类均由Apache Axis的内置工具Java2WSDL和WSDL2Java产生，这里就不对之进行说明了。

demo.productinfo.exception

• ProductInfoException： 自定义的异常类。通常在Java程序开发过程中，不要把系统底层的异常抛给用户，而应该以更加有意义的异常类取而代之，这就是为什么要有这个类的原因。

demo.productinfo.serverside
在这个包中，通过接口类定义了服务器端所有的行为。其下面的子包都是这些接口的具体实现。

• INotificationService： 定义了通告服务的服务方法。
• IProduct： 定义了商品类的基本行为。
• IProductInfoService： 定义了商品信息服务的方法。
• NotificationServiceSoapBindingSkeleton： 该类是由Apache Axis工具产生的服务端的框架类。
• ProductInfoServiceSoapBindingSkeleton： 该类是由Apache Axis工具产生的服务端的框架类。

demo.productinfo.serverside.product
在这个包内全部是具体的商品类。

• ProductTemplate: 该类是实现了IProduct接口的模板类。它包含了一些最基本的参数和方法。提供给其他的具体商品类继承之用。还有许多的商品类，这里就不一一罗列了。

demo.productinfo.serverside.serviceimplement
在这个包内是所有Web服务的具体实现类。

• NotificationServiceImp： 该类是数据同步服务的具体实现。
• ProductInfoImp： 商品查询服务的具体实现。
• ServerNotificationHandlerImp： 服务端数据同步处理器。

回页首

业务逻辑代理模式的实现

根据J2EE系统设计模式，业务逻辑代理通过向表现层隐藏了低层的实现，有效的减低表现层和商务逻辑层的耦合度，例如查找和调用EJB的细节。然而在本程序中，这种业务逻辑代理类对外隐藏了查找、调用Web服务和缓冲数据的复杂细节。

IProductInfoService接口类为客户端提供了关于商品信息的所有服务方法的描述。每个客户端必须自己处理SOAP 调用的查找、调用和缓冲。ProductInfoServiceDelegate类，从它的名字可知，它就是客户端的代理类。（在例子中，这个代理类并没有实现所有的Web服务方法调用，有兴趣的朋友可以自己补充完整）。

ProductInfoServiceDelegate类首先初始化一个IProductInfoService接口的实例，并且通过它来处理一切与底层SOAP相关的操作。然后，实例化一个SimpleCache类的静态实例，通过在所有的ProductInfoServiceDelegate类实例间共享这个实例来处理所有缓冲信息的操作。同时ProductInfoServiceDelegate类还包含一个DataChangeListener引用，用于触发注册的UI控件的界面更新事件，这里只是一个简单的实现，因此，一个ProductInfoServiceDelegate仅仅对应一个UI 控件，可以扩展为一个EventListenerList类，从而一个ProductInfoServiceDelegate可以拥有多个UI监听（但是更新UI又是一件危险的事，要注意只能在UI事件处理线程上刷新UI）。最后，ProductInfoServiceDelegate还实现了CacheExpiredListener接口，使它可以作为ClientNotificationHandler类的监听者，监听缓冲更新事件，以及时触发DataChange事件。

下面是ProductInfoServiceDelegate类的一些关键代码：

/**
            *<p>
            *Add a staff to server database and update the local cache.
            *</p>
            *
            *@param staff <code>IProdcut</code>
            *@return true if this operation is succeed or false for fail.
            */
            public boolean addStaff(IProduct staff) {
            boolean ret = false;
            if(staff != null) {
            try {
            synchronized(cache) {
            log.info("ProductInfo Service Delegate : Add Quote -> ["
            + staff.getName() + "]");
            ret = soap.addStaff(staff);
            if(ret == true) {
            log.info("ProductInfo Service Delegate : Updating Cache for [" +
            staff.getName() + "] ...");
            cache.addObject(String.valueOf(staff.getSN()), staff);
            }
            }
            }catch(ProductInfoException e) {
            log.error("ProductInfoException in addStaff: " + e.getMessage());
            }catch(RemoteException e) {
            log.error("RemoteException in addStaff: " + e.getMessage());
            }
            }
            return ret;
            }
            /**
            * <p>
            * Request the staff object. If we can find it from cache,then we got it and return. If
            * not we get it from the remote server and update the local cache.
            * </p>
            *
            * @param sn <code>String</code> - the staff's SN Number
            * @return The staff if we got it, or null for fail.
            */
            public IProduct getStaff(String sn) {
            IProduct staff = null;
            log.info(new Date() + "Prodcut Service Delegate : Getting Staff for [" + sn + "] ...");
            if(sn != null) {
            //Try to get this staff from the cache firstly.
            staff = (IProduct)cache.fetchObject(sn);
            //If we can not get it from local cache, do it again from the remote server.
            if(staff == null) {
            try {
            synchronized(cache) {
            //After the synchronized, we try it again to see if we can get it from cache.
            staff = (IProduct)cache.fetchObject(sn);
            if (staff != null) {
            return (staff);
            }
            staff = soap.getStaff(sn);
            if(staff != null) {
            cache.addObject(sn, staff);
            log.info("ProductInfo Service Delegate : Updating Cache for ["
            +staff.getName() + "] ...");
            }
            }
            }catch(RemoteException e) {
            log.error("RemoteException in getStaff: " + e.getMessage());
            }
            }
            }
            return staff;
            }
            /**
            * <p>
            * Get all of the staffs information.
            * </p>
            *
            * @return <code>java.util.Map</code> the map of all these staffs info.
            */
            public Map getAllStaffs() {
            log.info( new Date() + "ProductInfo Service Delegate : Getting All staffs...");
            if(cache == null || cache.isEmpty()) {
            try {
            synchronized (cache){
            if ( (cache != null) && (!cache.isEmpty())) {
            return cache.getAllObjectsHashtable();
            }
            Map tempMap = soap.getAllStaff();
            if(tempMap != null) {
            for(Iterator i = tempMap.keySet().iterator(); i.hasNext(); ) {
            String sn = (String)i.next();
            Object o  = tempMap.get(sn);
            cache.addObject(sn, o);
            }
            }
            }
            }catch(RemoteException e) {
            log.error("RemoteException in getAllStaffs: " + e.getMessage());
            }
            }
            return cache.getAllObjectsHashtable();
            }
            

下面是操作流程图：

由上可以清楚的看到，使用业务代理模式可以使程序员不必去关心底层的通信细节，而把注意力完全集中在实现商业逻辑上来。

回页首

缓冲管理模式的实现

当调用业务代理类的getStaff ()方法时，会首先试图从缓冲区中读取，如果无法找到，再向服务器端发出SOAP请求。当一个客户端程序添加或者更新了商品信息，它会首先调用Web服务方法更新服务器上的信息。这会触发服务端的dataChanged事件，导致所有的客户端都要更新本地缓冲区。然后，它在自己的本地缓冲区添加或更新该记录。其它的服务方法，也是一样的。目标就是将发送SOAP请求的次数减到最少。

根据缓冲管理模式，SimpleCache类应该包含两个方法，分别是addObject()和fetchObject()。一个CacheManager类通过ObjectKey来管理缓冲的信息。在本实现中，业务代理类就相当于CacheManager，这是由于每一个业务代理管理属于自己的SimpleCache。而ProductTemplate类实例就相当于ObjectKey。至于Cache的内部数据结构，出于简单的原因，采用了Hashtable。

现实中的程序里，可以通过扩展SimpleCache类，用更加严谨的内存管理机制轻易的替换这种基于Hashtable的简单实现（例如每次仅仅过期那些很少使用的缓冲信息），可以通过统计信息的点击次数或者复杂度来决定将要清除那些缓冲信息。可以利用Java的特性，如弱引用等来提高JVM的垃圾回收机制对被缓冲对象的清理效率。还可以通过创建一个全局的缓冲实例来统一管理整个客户端应用程序的缓冲信息。

总之，优化的方法是有很多很多的。

下面是，Cache类的简单实现代码：

/**
            * Empty constructor
            */
            public SimpleCache(){
            cache = new Hashtable();
            }
            /**
            * Constructor
            * @param size int the nitial size of the cache
            */
            public SimpleCache(int size){
            cache = new Hashtable(size);
            }
            /**
            * puts the key value pair in the cache based on the storage mechanism.
            *
            * @param key Object representing the key against which the value will be stored.
            * @param Value Object
            */
            public synchronized void addObject(Object key, Object value){
            if (key != null && value != null){
            cache.put(key, value);
            }
            }
            /**
            * fetchs the value from the cache based on the key.
            *
            * @param key Object representing the key against which the value will be found.
            * @returns Object
            */
            public Object fetchObject(Object key){
            if (key == null) {
            return null;
            }
            return cache.get(key);
            }
            /**
            * expire the value object from cache
            *
            * @param key Object representing the key against which the value will be found.
            */
            public synchronized void expire(Object key){
            if (key != null) {
            cache.remove(key);
            }
            }
            /**
            * expire the entire cache
            */
            public void expire(){
            cache.clear();
            }
            

下面的时序图演示了数据是如何被缓冲和缓冲是如何被更新的：

回页首

自动数据同步的实现

在这个例子程序中，所有的客户端都是自动同步数据的，也就是说一个客户端程序更新或添加了数据，马上就会在其它所有的客户端中体现出来，这个功能是通过通告处理机制实现的。在这个示例程序中，有两个数据同步处理类，分别是运行在服务器端的ServerNotificationHandlerImp和运行在客户端的ClientNotificationHandler。

下面将详细介绍，在这个程序中是怎样实现数据同步的。

众所周知，基于HTTP协议的SOAP是无法支持双向传播（Bi-directional Communication）的，可是又必须当服务端发生变化时，让所有的客户端程序接收到通告（例如，当其中一个客户端向服务端数据库添加了一条商品信息后，所有其它的客户端都应该收到通告，以更新自己的数据视图）。

根据SOAP 绑定协议可以轻易的将底层的通信协议换成双向传播协议，如BEEP (Blocks Extensible Exchange Protocol)。但是这样将失去HTTP协议的简单性，可扩展性和防火墙可穿透性。

因此，这里采用了阻塞的Web服务调用。为此专门提供了一个Web服务--NotificationService。所有调用该服务的客户端线程都会被服务端的ServerNotificationHandler Singleton类实例的isDataChanged方法阻塞，直到数据改变事件触发，该Web服务调用才会返回。在本例中，DataChanged是由另一个Web服务 --- ProductInfoImp触发的。

下面是ServerNotificationHandler类的两个关键方法：

public synchronized boolean isDataChanged() {
            while(true) {
            try {
            wait();
            break;
            }
            catch (Exception ignored) {
            }
            }
            return true;
            }
            public synchronized void dataChanged()  {
            notifyAll();
            }
            

在客户端，一个Singleton的ClientNotificationHandler单独运行在一个名为ClientNotificationHandlerThread的线程上。每个客户端都会创建这样一个线程，在这个线程上通过NotificationServiceDelegate代理类调用服务端的INotificationService服务的isDataChanged方法，并且被阻塞，只有当ServerNotificationHandlerImp的dataChanged方法被调用时，执行了Java线程的notifyAll操作才能返回。当该调用返回时，ClientNotificationHandler将注册的本地Cache全部过期，也就是触发了缓冲更新的事件。

下面ClientNotificationHandlerThread类的run()方法：

public void run() {
            while (true)   {
            if ((nsbd != null) && (nsbd.isDataChanged()))       {
            expireAllCaches();
            }
            else
            {
            // Sleep for some time before creating the
            // NotificationServiceDelegate.
            gotoSleep();
            initNotificationServiceBusinessDelegate();
            }
            }
            }
            

下面是通过Apache Axis自带的TCP Monitor监视SOAP Call的截图：

由上图可以清晰的看到，有一个SOAP调用一直没有结束，总是保持Active的状态，这就是对NotificationService的调用。当它返回的时候，必然会触发一个getAllQuotes的SOAP调用，然后又会有一个Active的连接。

这种方法也是有一定代价的。主要体现在它要求每一个客户端都必须起一个线程来等待接收通告，而在服务器端对于每一个注册的客户端连结都有一个线程阻塞的等待发出通告。绝大多数的企业级应用程序服务器都可以游刃有余的对应几百个客户端。但当同时有上千个客户端连结的时候，那又是另一回事了。这时候，只有采用非阻塞调用，ServerNotificationHandler将通知事件存储到队列中去，同时客户端的ClientNotificationHandler周期性的调用NotificationService服务。并且出于演示的原因，这个例子的数据同步模块已经被尽量的简化。真正的实现并不会总是使所有客户端的Cache全部过期。一个更具鲁棒性的设计可以让服务端的ServerNotificationHandlerImp传递需要被更新Cache数据的信息，甚至可以详细到哪一个对象实例需要被更新。这样一来，ClientNotificationHandler可以调用更加有效的代理类方法（如expiredOneCache）,来更新局部的Cache信息。

下图展示了数据同步模块的工作流程图：

回页首

客户端界面

客户端主要两个功能组件，第一个是StaffInfoViewPanel用于显示最新的商品信息。另一个是DataEditPanel用于更新和添加商品信息。这些GUI组件都是通过封装的很好的ProductInfoServiceDelegate代理类来与后台通信的。

下面是运行时界面截图：

可以清楚的看出，当一个客户端程序更新后台数据库的时候，其它的客户端也会实时的更新自己的数据视图。

回页首

具体实现中遇到的问题

本文所带的例子，是在Eclipse 2.1IDE上开发完成的，SOAP引擎选用了Apache Axis1.1 Final。这些工具提供了十分快捷的开发方式。下面仅对开发过程中遇到的一些代表性的问题进行简单分析。

• 如何用SOAP传递Hashtable

  这个问题在Apache Axis的官方 Mail List上，一直是一个非常火的问题。由于本文的例子也采用Hashtable这种数据结构，所以在此描述一下如何解决这个问题。首先，本例中传送的Hashtable的key为字符串型，value为StockQuote类型，其中StockQuote类是符合标准JavaBean规则的。因此，可以使用Axis自带的BeanSerializer和BeanDeserializer，但是在发布WebService的时候，必须配置服务端的序列化器，如下所示：

  <deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"> <service name="ProductInfoService" provider="java:RPC" style="rpc" use="encoded"> <parameter name="wsdlTargetNamespace" value="http://serverside.productinfo.demo"/> <parameter name="wsdlServiceElement" value="IProductInfoServiceService"/> <parameter name="wsdlServicePort" value="ProductInfoService"/> <parameter name="className" value="demo.productinfo.serverside.ProductInfoServiceSoapBindingSkeleton"/> <parameter name="wsdlPortType" value="IProductInfoService"/> <parameter name="allowedMethods" value="*"/> <parameter name="scope" value="Application"/> <typeMapping xmlns:ns="http://product.serverside.productinfo.demo" qname="ns: ProductTemplate" type="java:demo.productinfo.serverside.product.ProductTemplate" serializer="org.apache.axis.encoding.ser.BeanSerializerFactory" deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" /> <typeMapping xmlns:ns="http://exception.productinfo.demo" qname="ns:ProductInfoException" type="java:demo.productinfo.exception.ProductInfoException" serializer="org.apache.axis.encoding.ser.BeanSerializerFactory" deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" /> </service> </deployment>

  
  

  请注意其中的<typeMapping/>节点，必须显示的为ProductTemplate类指定序列化器和反序列化器。否则，服务端会抛出org.xml.sax.SAXException异常。

  在客户端，可以直接使用通过Axis自带的WSDL2JAVA工具产生的可序列化的ProductTemplate类，也可以使用自己的ProductTemplate类，只要严格符合JavaBean标准规范。

• 如何调整后台服务的生存周期

  由于本例子程序，没有采用数据库，而只是简单的使用Hashtable做为存储商品信息的数据结构。如何保证数据的持久性呢？一般的Web服务只提供无状态的服务，类似于每一次客户端的SOAP调用，服务器端都会创建一个新的类实例来进行处理，你可以把它想象成Stateless Session Bean。为此，Apache Axis支持简单的三个级别的后台服务，分别为：Request、Session和Application。Request级别是默认的选项，它代表每次SOAP请求，都会创建一个新的对象来处理。Session级别代表客户端的每个Session有一个对应的后台对象进行处理。Application级别代表所有客户端的SOAP请求都会共享同一个后台服务实例对象，并且要由程序员自己来保证其数据的同步问题。在本例子中就是采用了Application级的服务。

  实施的过程如下：

  服务端：在WSDD文件中的每个服务的描述下，添加这样一行：

  <parameter name="scope" value="Application"/>

  
  

• 如何避免Session Timeout

  Apache Axis1.1 Final的一个极具争议性的改变就是将原本的无Session Timeout时间限制，默认设置为60秒。这对例子程序有很大的影响，因为例子中每个客户端都需要与Server保持一个长连接，如果有超时设定，那么这个假设将会被破坏。因此，必须取消超时限制。取消方法如下：

  FooServiceLocator loc = new FooServiceLocator(); FooService binding = loc.getFooService(); org.apache.axis.client.Stub s = (Stub) binding; s.setTimeout(0); // 1 second, in miliseconds

  
  

  对于这个问题，Axis的 Mail List上也处在激烈的争论中，也许在1.2版中就会取消默认60秒的设定。让我们拭目以待吧！

回页首

总结

Web服务虽然已经取得了长足的发展，涌现出大量设计优良的SOAP引擎，如Apache Axis等，它们采用最新的技术在底层效率上已经做出了很大提高，但是由于SOAP协议的一些固有的特性，例如序列化和反序列化效率，传输效率等等问题，整体的效果仍然不尽如人意。但也不需担心，利用设计模式，可以解决大部分的问题。我们有理由相信它美好的未来。

本文中，在设计模式的帮助下，实现了一个透明的客户端缓冲SOAP调用的机制。现实中的程序还必须充分考虑到数据库持久性，全局Cache管理，资源回收，与其他Web服务平台的互操作性，安全性和更加有效的异常处理等问题。

由于在语言级提供了线程支持，在 Java 语言中使用多线程要远比在 C 或 C++ 中来得简单。本文通过简单的程序示例展现了在 Java 程序中线程编程的简单性。在学习完本文后，用户应该能够编写简单、多线程的程序。

在 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 和其他语言中使用过线程，在那些语言中对线程没有语言支持。这些程序员可能通常都被搞得对线程失去了信心。

1、在运行时判断任意一个对象所属的类。
Class cls = Class.forName("com.jdk");
返回true
System.out.print(cls.isInstance(new jdk()));

2、在运行时构造任意一个类的对象。
Class cls = Class.forName("com.jdk");
jdk jdkobj = cls.newInstance();

3、在运行时判断任意一个类所具有的成员变量和方法。
Class cls = Class.forName("com.jdk");
Methods methods[]= cls.getDecliedMethod();
Fields  fields[] = cls.getDeclieredFields();

4、在运行时调用任意一个对象的方法
Class cls = Class.forName("com.jdk");
Methods methods[]= cls.getDecliedMethod();
jdk jdkobj = new jdk();
String returnvalue = methods.invoke(jdkobj,null)

其中第四种方法最长使用：
主要有：
a.配置文件创建form对象。并初始化。
    1、使用配置文件产生类的实例。通过配置文件中提供的名称生成类的实例。
    2、使用类的实例，根据request中的参数生成一个properties文件，之后使用beanUtils.populte(form,pro);
    对form的属性进行复制，其中就是使用reflect方法。
b.当你不知道要创建什么类型的对象时，使用在运行时提供类的完整路径的方式来生成类的实例时，
    例如：
    在struts中对messageResources引用的生成中，使用到工厂方法的模式，对于他所要使用的工厂，他采用的是factoryClass参数来生成工厂，之后使用这个工厂的实例来生成messageResources对象。
    这其中就使用到了使用reflect产生类的实例。

c.当对象的方法只有在运行时才知道那些方法被调用，那些方法不用调用时，且方法遵循一定的规律生成，而且方法很对，比如100个。

例如：
使用日历生成客户经理的月报时，因为一个月是1到31天（最长），我们通过在数据库中配置客户经理日历的表，其中有
customerid,customercode,no1,no2,no3,no4,no5------,no31,remark,tag,status   .......
生成的bean和上面的表的字段相对性，如customerbean
我们通过jdbc从数据库查询得到客户经理每个月的数据，通过画表格的方式生成客户经理月报，输出每天的记录时，调用bean的1-31天的方法，如果不采用reflect那么将会是恼人的代码，采用reflect则会节省很多的时间和空间，

d.最有用的也是最经常使用的，通过回调的方式从resultset中查询数据，查询字段和类型的内容是动态的，查询的sql也是动态的即结果集是动态的。这时我们可以很好的使用反射机制。通过指定的字段和类型，使用反射的方法在结果集中查找，并封装成map传回。

　　Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++  中就没有办法在程序中获得函数定义相关的信息。

　　JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件（类） 的属性。

　　1. 一个简单的例子

　　考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*; public class DumpMethods { public static void main(String args[]) { try { Class c = Class.forName(args[0]); Method m[] = c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) System.out.println(m[i].toString()); } catch (Throwable e) { System.err.println(e); } } }

　　按如下语句执行：

　　java DumpMethods java.util.Stack

　　它的结果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object) public synchronized java.lang.Object java.util.Stack.pop() public synchronized java.lang.Object java.util.Stack.peek() public boolean java.util.Stack.empty() public synchronized int java.util.Stack.search(java.lang.Object)

　　这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

　　这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

　　2.开始使用 Reflection

　　用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

　　下面就是获得一个 Class 对象的方法之一：

　　Class c = Class.forName（"java.lang.String"）；

　　这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

　　Class c = int.class；

　　或者

　　Class c = Integer.TYPE；

　　它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 （如 Integer） 中预先定义好的 TYPE 字段。

　　第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

        一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

　　Class c = Class.forName（"java.lang.String"）；

　　Method m[] = c.getDeclaredMethods（）；

　　System.out.println（m[0].toString（））；

　　它将以文本方式打印出 String 中定义的第一个方法的原型。

　　在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。

　　模拟 instanceof 操作符

　　得到类信息之后，通常下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法可以用于模拟 instanceof 操作符：

class A { } public class instance1 { public static void main(String args[]) { try { Class cls = Class.forName("A"); boolean b1 = cls.isInstance(new Integer(37)); System.out.println(b1); boolean b2 = cls.isInstance(new A()); System.out.println(b2); } catch (Throwable e) { System.err.println(e); } } }

　　在这个例子中创建了一个 A 类的 Class 对象，然后检查一些对象是否是 A 的实例。Integer（37） 不是，但 new A（）是。

　　3.找出类的方法

　　找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法。下面的代码就实现了这一用法：

import java.lang.reflect.*; public class method1 { private int f1(Object p, int x) throws NullPointerException { if (p == null) throw new NullPointerException(); return x; } public static void main(String args[]) { try { Class cls = Class.forName("method1"); Method methlist[] = cls.getDeclaredMethods(); for (int i = 0; i < methlist.length; i++) { Method m = methlist[i]; System.out.println("name = " + m.getName()); System.out.println("decl class = " + m.getDeclaringClass()); Class pvec[] = m.getParameterTypes(); for (int j = 0; j < pvec.length; j++) System.out.println("param #" + j + " " + pvec[j]); Class evec[] = m.getExceptionTypes(); for (int j = 0; j < evec.length; j++) System.out.println("exc #" + j + " " + evec[j]); System.out.println("return type = " + m.getReturnType()); System.out.println("-----"); } } catch (Throwable e) { System.err.println(e); } } }

　　这个程序首先取得 method1 类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。如果你在程序中使用 getMethods 来代替 getDeclaredMethods，你还能获得继承来的各个方法的信息。

取得了 Method 对象列表之后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型还是类类型，都可以由描述类的对象按顺序给出。

　　输出的结果如下：

name = f1 decl class = class method1   param #0 class java.lang.Object param #1 int exc #0 class java.lang.NullPointerException return type = int ----- name = main decl class = class method1 param #0 class [Ljava.lang.String; return type = void

　　4.获取构造器信息

　　获取类构造器的用法与上述获取方法的用法类似，如：

import java.lang.reflect.*; public class constructor1 { public constructor1() { } protected constructor1(int i, double d) { } public static void main(String args[]) { try { Class cls = Class.forName("constructor1"); Constructor ctorlist[] = cls.getDeclaredConstructors(); for (int i = 0; i < ctorlist.length; i++) { Constructor ct = ctorlist[i]; System.out.println("name = " + ct.getName()); System.out.println("decl class = " + ct.getDeclaringClass()); Class pvec[] = ct.getParameterTypes(); for (int j = 0; j < pvec.length; j++) System.out.println("param #" + j + " " + pvec[j]); Class evec[] = ct.getExceptionTypes(); for (int j = 0; j < evec.length; j++) System.out.println("exc #" + j + " " + evec[j]); System.out.println("-----"); } } catch (Throwable e) { System.err.println(e); } } }

　　这个例子中没能获得返回类型的相关信息，那是因为构造器没有返回类型。

　　这个程序运行的结果是：

name = constructor1 decl class = class constructor1 ----- name = constructor1 decl class = class constructor1 param #0 int param #1 double

　　找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情：

import java.lang.reflect.*; public class field1 { private double d; public static final int i = 37; String s = "testing";   public static void main(String args[]) { try { Class cls = Class.forName("field1"); Field fieldlist[] = cls.getDeclaredFields(); for (int i = 0; i < fieldlist.length; i++) { Field fld = fieldlist[i]; System.out.println("name = " + fld.getName()); System.out.println("decl class = " + fld.getDeclaringClass()); System.out.println("type = " + fld.getType()); int mod = fld.getModifiers(); System.out.println("modifiers = " + Modifier.toString(mod)); System.out.println("-----"); } } catch (Throwable e) { System.err.println(e); } } }

　　这个例子和前面那个例子非常相似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 （如“static”在“final”之前）。这个程序的输出是：

name = d decl class = class field1 type = double modifiers = private ----- name = i decl class = class field1 type = int modifiers = public static final ----- name = s decl class = class field1 type = class java.lang.String modifiers =

　　和获取方法的情况一下，获取字段的时候也可以只取得在当前类中申明了的字段信息 （getDeclaredFields），或者也可以取得父类中定义的字段 （getFields） .

　　6.根据方法的名称来执行方法

　　文本到这里，所举的例子无一例外都与如何获取类的信息有关。我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：

import java.lang.reflect.*; public class method2 { public int add(int a, int b) { return a + b; } public static void main(String args[]) { try { Class cls = Class.forName("method2"); Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; partypes[1] = Integer.TYPE; Method meth = cls.getMethod("add", partypes); method2 methobj = new method2(); Object arglist[] = new Object[2]; arglist[0] = new Integer(37); arglist[1] = new Integer(47); Object retobj = meth.invoke(methobj, arglist); Integer retval = (Integer) retobj; System.out.println(retval.intValue()); } catch (Throwable e) { System.err.println(e); } } }

　　假如一个程序在执行的某处的时候才知道需要执行某个方法，这个方法的名称是在程序的运行过程中指定的 （例如，JavaBean 开发环境中就会做这样的事），那么上面的程序演示了如何做到。

　　上例中，getMethod用于查找一个具有两个整型参数且名为 add 的方法。找到该方法并创建了相应的Method 对象之后，在正确的对象实例中执行它。执行该方法的时候，需要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的同样是一个 Integer 对象，它封装了返回值 84.

7.创建新的对象

　　对于构造器，则不能像执行方法那样进行，因为执行一个构造器就意味着创建了一个新的对象 （准确的说，创建一个对象的过程包括分配内存和构造对象）。所以，与上例最相似的例子如下：

import java.lang.reflect.*; public class constructor2 { public constructor2() { } public constructor2(int a, int b) { System.out.println("a = " + a + " b = " + b); } public static void main(String args[]) { try { Class cls = Class.forName("constructor2"); Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; partypes[1] = Integer.TYPE; Constructor ct = cls.getConstructor(partypes); Object arglist[] = new Object[2]; arglist[0] = new Integer(37); arglist[1] = new Integer(47); Object retobj = ct.newInstance(arglist); } catch (Throwable e) { System.err.println(e); } } }

　　根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。

　　8.改变字段（域）的值

　　reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：

import java.lang.reflect.*; public class field2 { public double d; public static void main(String args[]) { try { Class cls = Class.forName("field2"); Field fld = cls.getField("d"); field2 f2obj = new field2(); System.out.println("d = " + f2obj.d); fld.setDouble(f2obj, 12.34); System.out.println("d = " + f2obj.d); } catch (Throwable e) { System.err.println(e); } } }

　　这个例子中，字段 d 的值被变为了 12.34.

　　9.使用数组

　　本文介绍的 reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：

import java.lang.reflect.*; public class array1 { public static void main(String args[]) { try { Class cls = Class.forName("java.lang.String"); Object arr = Array.newInstance(cls, 10); Array.set(arr, 5, "this is a test"); String s = (String) Array.get(arr, 5); System.out.println(s); } catch (Throwable e) { System.err.println(e); } } }

　　例中创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋了值，最后将这个字符串从数组中取得并打印了出来。

　　下面这段代码提供了一个更复杂的例子：

import java.lang.reflect.*; public class array2 { public static void main(String args[]) { int dims[] = new int[]{5, 10, 15}; Object arr = Array.newInstance(Integer.TYPE, dims); Object arrobj = Array.get(arr, 3); Class cls = arrobj.getClass().getComponentType(); System.out.println(cls); arrobj = Array.get(arrobj, 5); Array.setInt(arrobj, 10, 37); int arrcast[][][] = (int[][][]) arr; System.out.println(arrcast[3][5][10]); } }

　　例中创建了一个 5 x 10 x 15 的整型数组，并为处于 [3][5][10] 的元素赋了值为 37.注意，多维数组实际上就是数组的数组，例如，第一个 Array.get 之后，arrobj 是一个 10 x 15 的数组。进而取得其中的一个元素，即长度为 15 的数组，并使用 Array.setInt 为它的第 10 个元素赋值。

　　注意创建数组时的类型是动态的，在编译时并不知道其类型。

HashMap可谓JDK的一大实用工具，把各个Object映射起来，实现了“键－－值”对应的快速存取。但实际里面做了些什么呢？

在这之前，先介绍一下负载因子和容量的属性。大家都知道其实一个 HashMap 的实际容量就 因子*容量，其默认值是 16×0.75＝12； 这个很重要，对效率很一定影响！当存入HashMap的对象超过这个容量时，HashMap 就会重新构造存取表。这就是一个大问题，我后面慢慢介绍，反正，如果你已经知道你大概要存放多少个对象，最好设为该实际容量的能接受的数字。

两个关键的方法，put和get：

先有这样一个概念，HashMap是声明了 Map，Cloneable, Serializable 接口，和继承了 AbstractMap 类，里面的 Iterator 其实主要都是其内部类HashIterator 和其他几个 iterator 类实现，当然还有一个很重要的继承了Map.Entry 的 Entry 内部类，由于大家都有源代码，大家有兴趣可以看看这部分，我主要想说明的是 Entry 内部类。它包含了hash，value，key 和next 这四个属性，很重要。put的源码如下

public Object put(Object key, Object value) {
            Object k = maskNull(key); 

这个就是判断键值是否为空，并不很深奥，其实如果为空，它会返回一个static Object 作为键值，这就是为什么HashMap允许空键值的原因。

int hash = hash(k);
            int i = indexFor(hash, table.length);
            

这连续的两步就是 HashMap 最牛的地方！研究完我都汗颜了，其中 hash 就是通过 key 这个Object的 hashcode 进行 hash，然后通过 indexFor 获得在Object table的索引值。

table？不要惊讶，其实HashMap也神不到哪里去，它就是用 table 来放的。最牛的就是用 hash 能正确的返回索引。其中的hash算法，我跟JDK的作者 Doug 联系过，他建议我看看《The art of programing vol3》可恨的是，我之前就一直在找，我都找不到，他这样一提，我就更加急了，可惜口袋空空啊！

不知道大家有没有留意 put 其实是一个有返回的方法，它会把相同键值的 put 覆盖掉并返回旧的值！如下方法彻底说明了 HashMap 的结构，其实就是一个表加上在相应位置的Entry的链表：

for (Entry e = table[i]; e != null; e = e.next) {
            if (e.hash == hash && eq(k, e.key)) {
            Object oldvalue = e.value;
            e.value = value; //把新的值赋予给对应键值。
            e.recordAccess(this); //空方法，留待实现
            return oldvalue; //返回相同键值的对应的旧的值。
            }
            }
            modCount++; //结构性更改的次数
            addEntry(hash, k, value, i); //添加新元素，关键所在！
            return null; //没有相同的键值返回
            }
            

void addEntry(int hash, Object key, Object value, int bucketIndex) {
            table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]);
            

if (size++ >= threshold) //这个threshold就是能实际容纳的量
            resize(2 * table.length); //超出这个容量就会将Object table重构
            

所谓的重构也不神，就是建一个两倍大的table（我在别的论坛上看到有人说是两倍加1，把我骗了），然后再一个个indexfor进去！注意！！这就是效率！！如果你能让你的HashMap不需要重构那么多次，效率会大大提高！

说到这里也差不多了，get比put简单得多，大家，了解put，get也差不了多少了。对于collections我是认为，它是适合广泛的，当不完全适合特有的，如果大家的程序需要特殊的用途，自己写吧，其实很简单。（作者是这样跟我说的，他还建议我用LinkedHashMap,我看了源码以后发现，LinkHashMap其实就是继承HashMap的，然后override相应的方法，有兴趣的同人，自己looklook）建个 Object table，写相应的算法，就ok啦。

举个例子吧，像 Vector，list 啊什么的其实都很简单，最多就多了的同步的声明，其实如果要实现像Vector那种，插入，删除不多的，可以用一个Object table来实现，按索引存取，添加等。

如果插入，删除比较多的，可以建两个Object table，然后每个元素用含有next结构的，一个table存，如果要插入到i，但是i已经有元素，用next连起来，然后size＋＋，并在另一个table记录其位置。

   对于HashMap主要以键值(key-value)的方式来体现，笼统的说就是采用key值的哈希算法来，外加取余最终获取索引，而这个索引可以认定是一种地址，既而把相应的value存储在地址指向内容中。这样说或许比较概念化，也可能复述不够清楚，来看列式更加清晰：

其实最终就是这两个式子决定了值得存储位置。但是以上两个表达式还有欠缺。为什么这么说？例如在key.hashCode()后可能存在是一个负整数，你会问：是啊，那这个时候怎么办呢？所以在这里就需要进一步加强改造式子2了，修改后的：

到这里又迷惑了，为什么上面是这样的呢？对于先前我们谈到在hash有可能产生负数的情况，这里我们使用当前的hash做一个“与”操作，在这里需要和int最大的值相“与”。这样的话就可以保证数据的统一性，把有符号的数值给“与”掉。而一般这里我们把二进制的数值转换成16进制的就变成了：Ox7FFFFFFF。（注：与操作的方式为，不同为0，相同为1）。而对于hashCode()的方法一般有：

说道这里大家可能会说，到这里算完事了吧。但是你可曾想到如果数据都采用上面的方式，最终得到的可能index会相同怎么办呢？如果你想到的话，那恭喜你!又增进一步了，这里就是要说到一个名词：冲突率。是的就是前面说道的一旦index有相同怎么办？数据又该如何存放呢，而且这个在数据量非常庞大的时候这个基率更大。这里按照算法需要明确的一点：每个键（key）被散列分布到任何一个数组索引的可能性相同，而且不取决于其它键分布的位置。这句话怎么理解呢？从概率论的角度，也就是说如果key的个数达到一个极限，每个key分布的机率都是均等的。更进一步就是：即便key1不等于key2也还是可能key1.hashCode()=key2.hashCode()。

对于早期的解决冲突的方法有折叠法（folding)，例如我们在做系统的时候有时候会采用部门编号附加到某个单据标号后，这里比如产生一个9～11位的编码。通过对半折叠做。

现在的策略有：

1.      键式散列 

2.      开放地址法

在了解这两个策略前，我们先定义清楚几个名词解释：

清晰了这几个定义，我们再来看具体的解决方式

键式散列：

我们直接看一个实例，这样就更加清晰它的工作方式，从而避免文字定义。我们这里还是来举一个图书编号的例子，下面比如有这样一些编号：

                        78938-0000

                         45678-0001

                         72678-0002

                         24678-0001

                         16678-0001

                         98678-0003

                         85678-0002

                         45232-0004

步骤：

1.      把编号作为key,即：int hash=key.hashCode();

2.      int index=hash%表大小；

3.      逐步按顺序插入对象中

现在问题出现了：对于编号通过散列算法后很可能产生相同的索引值，意味着存在冲突。

解释上面的操作：如果对于key.hashCode()产生了冲突（比如途中对于插入24678-0001对于通过哈希算法后可能产生的index或许也是501），既而把相应的前驱有相同的index的对象指向当前引用。这也就是大家认定的单链表方式。以此类推…

而这里存在冲突对象的元素放在Entry对象中，Entry具有以下一些属性：

int hash;

Object key;

Entry next;

对于Entry对象就可以直接追溯到链表数据结构体中查阅。

开放地址法：

1.        线性地址探测法：

如何理解这个概念呢，一句话：就是通过算法规则在对象地址N+1中查阅找到为NULL的索引内容。

处理方式：如果index索引与当前的index有冲突，即把当前的索引index+1。如果在index+1已经存在占位现象（index+1的内容不为NULL）试图接着index+2执行。。。直到找到索引为内容为NULL的为止。这种处理方式也叫：线性地址探测法(offset-of-1)

如果采用线性地址探测法会带来一个效率的不良影响。现在我们来分析这种方式会带来哪些不良因素。大家试想下如果一个非常庞大的数据存储在Map中，假如在某些记录集中有一些数据非常相似（他们产生的索引在内存的某个块中非常的密集），也就是说他们产生的索引地址是一个连续数值，而造成数据成块现象。另一个致命的问题就是在数据删除后，如果再次查询可能无法定到下一个连续数字，这个又是一个什么概念呢？例如以下图片就很好的说明开发地址散列如何把数据按照算法插入到对象中：

对于上图的注释步骤说明：

从数据“78938-0000”开始通过哈希算法按顺序依次插入到对象中，例如78938-0000通过换

算得到索引为0，当前所指内容为NULL所以直接插入；45678-0001同样通过换算得到索引为地址501所指内容，当前内容为NULL所以也可以插入；72678-0002得到索引502所指内容，当前内容为NULL也可以插入；请注意当24678-0001得到索引也为501，当前地址所指内容为45678-0001。即表示当前数据存在冲突，则直接对地址501+1=502所指向内容为72678-0002不为NULL也不允许插入，再次对索引502+1=503所指内容为NULL允许插入。。。依次类推只要对于索引存在冲突现象，则逐次下移位知道索引地址所指为NULL；如果索引不冲突则还是按照算法放入内容。对于这样的对象是一种插入方式，接下来就是我们的删除(remove)方法了。按照常理对于删除，方式基本区别不大。但是现在问题又出现了，如果删除的某个数据是一个存在冲突索引的内容，带来后续的问题又会接踵而来。那是什么问题呢？我们还是同样来看看图示的描述，对于图-2中如果删除(remove)数据24678-0001的方法如下图所示：

对于我们会想当然的觉得只要把指向数据置为NULL就可以,这样的做法对于删除来说当然是没有问题的。如果再次定位检索数据16678-0001不会成功，因为这个时候以前的链路已经堵上了，但是需要检索的数据事实上又存在。那我们如何来解决这个问题呢？对于JDK中的Entry类中的方法存在一个：boolean markedForRemoval;它就是一个典型的删除标志位，对于对象中如果需要删除时，我们只是对于它做一个“软删除”即置一个标志位为true就可以。而插入时，默认状态为false就可以。这样的话就变成以下图所示：

通过以上方式更好的解决冲突地址删除数据无法检索其他链路数据问题了。

2.        双散列（余商法）

在了解开放地址散列的时候我们一直在说解决方法，但是大家都知道一个数据结构的完善更多的是需要高效的算法。这当中我们却没有涉及到。接下来我们就来看看在开放地址散列中它存在的一些不足以及如何改善这样的方法，既而达到无论是在方法的解决上还是在算法的复杂度上更加达到高效的方案。

在图2-1中类似这样一些数据插入进对象，存在冲突采用不断移位加一的方式，直到找到不为NULL内容的索引地址。也正是由于这样一种可能加大了时间上的变慢。大家是否注意到像图这样一些数据目前呈现出一种连续索引的插入，而且是一种成块是的数据。如果数据量非常的庞大，或许这种可能性更大。尽管它解决了冲突，但是对于数据检索的时间度来说，我们是不敢想象的。所有分布到同一个索引index上的key保持相同的路径：index,index+1,index+2…依此类推。更加糟糕的是索引键值的检索需要从索引开始查找。正是这样的原因，对于线性探索法我们需要更进一步的改进。而刚才所描述这种成块出现的数据也就定义成：簇。而这样一种现象称之为：主簇现象。

（主簇：就是冲突处理允许簇加速增长时出现的现象）而开放式地址冲突也是允许主簇现象产生的。那我们如何来避免这种主簇现象呢？这个方式就是我们要来说明的：双散列解决冲突法了。主要的方式为：

u      int hash=key.hasCode();

u      int index=(hash&Ox7FFFFFFF)%table.length;

u      按照以上方式得到索引存在冲突，则开始对当前索引移位，而移位方式为：

        ffset=(hash&Ox7FFFFFFF)/table.length;

u      如果第一次移位还存在同样的冲突，则继续：当前冲突索引位置（索引号+余数）%表.length

u      如果存在的余数恰好是表的倍数，则作偏移位置为一下移，依此类推

这样双散列冲突处理就避免了主簇现象。至于HashSet的原理基本和它是一致的，这里不再复述。在这里其实还是主要说了一些简单的解决方式，而且都是在一些具体参数满足条件下的说明，像一旦数据超过初始值该需要rehash，加载因子一旦大于1.0是何种情况等等。还有很多问题都可以值得我们更加进一步讨论的，比如：在java.util.HashMap中的加载因子为什么会是0.75，而它默认的初始大小为什么又是16等等这些问题都还值得说明。要说明这些问题可能又需要更加详尽的说明清楚。


源码分析:HashMap

HashMap是Java新Collection Framework中用来代替HashTable的一个实现，HashMap和HashTable的区别是： HashMap是未经同步的，而且允许null值。HashTable继承Dictionary，而且使用了Enumeration，所以被建议不要使用。
HashMap的声明如下：
public class HashMap extends AbstractMap implements Map, Cloneable,Serializable
有关AbstractMap：http://blog.csdn.net/treeroot/archive/2004/09/20/110343.aspx
有关Map：http://blog.csdn.net/treeroot/archive/2004/09/20/110331.aspx
有关Cloneable：http://blog.csdn.net/treeroot/archive/2004/09/07/96936.aspx
这个类比较复杂，这里只是重点分析了几个方法，特别是后面涉及到很多内部类都没有解释
不过都比较简单。

static final int DEFAULT_INITIAL_CAPACITY = 16; 默认初始化大小

static final int MAXIMUM_CAPACITY = 1 << 30; 最大初始化大小

static final float DEFAULT_LOAD_FACTOR = 0.75f; 默认加载因子

transient Entry[] table; 一个Entry类型的数组，数组的长度为2的指数。

transient int size; 映射的个数

int threshold; 下一次扩容时的值

final float loadFactor; 加载因子

transient volatile int modCount; 修改次数

public HashMap(int initialCapacity, float loadFactor) {
　　 if (initialCapacity < 0)
　　　　 throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);
　　 if (initialCapacity > MAXIMUM_CAPACITY)
　　　　 initialCapacity = MAXIMUM_CAPACITY;
　　 if (loadFactor <= 0 || Float.isNaN(loadFactor))
　　　　 throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
　　 int capacity = 1;
　　 while (capacity < initialCapacity)
　　　　 capacity <<= 1;
　　 this.loadFactor = loadFactor;
　　 threshold = (int)(capacity * loadFactor);
　　 table = new Entry[capacity];
　　 init();
}

public HashMap(int initialCapacity) {
　　 this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {
　　 this.loadFactor = DEFAULT_LOAD_FACTOR;
　　 threshold = (int)(DEFAULT_INITIAL_CAPACITY);
　　　　　　注意：这里应该是一个失误！ 应该是：threshold =(int)(DEFAULT_INITIAL_CAPACITY * loadFactor);
　　 table = new Entry[DEFAULT_INITIAL_CAPACITY];
　　　init();
}

public HashMap(Map m) {
　　 this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　DEFAULT_LOAD_FACTOR);
　　 putAllForCreate(m);
}

void init() {}

static final Object NULL_KEY = new Object();

static Object maskNull(Object key){
　　 return (key == null ? NULL_KEY : key);
}

static Object unmaskNull(Object key) {
　　 return (key == NULL_KEY ? null : key);
}

static int hash(Object x) {
　　 int h = x.hashCode();
　　 h += ~(h << 9);
　　 h ^= (h >>> 14);
　　 h += (h << 4);
　　 h ^= (h >>> 10);
return h;
}
在HashTable中没有这个方法，也就是说HashTable中是直接用对象的hashCode值，但是HashMap做了改进 用这个算法来获得哈希值。

static boolean eq(Object x, Object y) {
　 　return x == y || x.equals(y);
}

static int indexFor(int h, int length) {
　　 return h & (length-1);
}
根据哈希值和数组的长度来返回该hash值在数组中的位置，只是简单的与关系。

public int size() {
　　 return size;
}

public boolean isEmpty() {
　　return size == 0;
}

public Object get(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (true) {
　　　　 if (e == null) return e;
　　　　 if (e.hash == hash && eq(k, e.key)) return e.value;
　　　　 e = e.next;
　　 }
}
这个方法是获取数据的方法，首先获得哈希值，这里把null值掩饰了，并且hash值经过函数hash()修正。 然后计算该哈希值在数组中的索引值。如果该索引处的引用为null，表示HashMap中不存在这个映射。 否则的话遍历整个链表，这里找到了就返回,如果没有找到就遍历到链表末尾，返回null。这里的比较是这样的：e.hash==hash && eq(k,e.key) 也就是说如果hash不同就肯定认为不相等，eq就被短路了，只有在 hash相同的情况下才调用equals方法。现在我们该明白Object中说的如果两个对象equals返回true，他们的 hashCode应该相同的道理了吧。假如两个对象调用equals返回true，但是hashCode不一样，那么在HashMap 里就认为他们不相等。

public boolean containsKey(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (e != null) {
　　　　 if (e.hash == hash && eq(k, e.key)) return true;
　　　　 e = e.next;
　　 }
　　return false;
}
这个方法比上面的简单，先找到哈希位置，再遍历整个链表，如果找到就返回true。

Entry getEntry(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (e != null && !(e.hash == hash && eq(k, e.key)))
　　　　 e = e.next;
　　 return e;
}
这个方法根据key值返回Entry节点，也是先获得索引位置，再遍历链表，如果没有找到返回的是null。

public Object put(Object key, Object value) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 for (Entry e = table[i]; e != null; e = e.next) {
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　 Object oldValue = e.value;
　　　　　　 e.value = value;
　　　　　　 e.recordAccess(this);
　　　　　　 return oldValue;
　　　　 }
　　 }
　　 modCount++;
　　 addEntry(hash, k, value, i);
　　 return null;
}
首先获得hash索引位置，如果该位置的引用为null，那么直接插入一个映射，返回null。如果此处的引用不是null，必须遍历链表，如果找到一个相同的key，那么就更新该value，同时返回原来的value值。如果遍历完了没有找到，说明该key值不存在，还是插入一个映射。如果hash值足够离散的话，也就是说该索引没有被使用的话，那么不不用遍历链表了。相反，如果hash值不离散，极端的说如果是常数的话，所有的映射都会在这一个链表上，效率会极其低下。这里举一个最简单的例子，写两
个不同的类作为key插入到HashMap中，效率会远远不同。
class Good{
　　int i;
　　public Good(int i){
　　　this.i=i;
　　}
　　public boolean equals(Object o){
　　　return (o instanceof Good) && (this.i==((Good)o).i)
　　}
　　public int hashCode(){
　　　return i;
　　}
}
class Bad{
　　int i;
　　public Good(int i){
　　　　this.i=i;
　　}
　　public boolean equals(Object o){
　　　　return (o instanceof Good) && (this.i==((Good)o).i)

推荐圈子: GT-Grid
更多相关推荐 下面这些是在开发中用到的一些东西，有的代码贴的不是完整的，只是贴出了关于操作EXCEL的代码：

jxl是一个*国人写的java操作excel的工具, 在开源世界中，有两套比较有影响的API可供使用，一个是POI，一个是jExcelAPI。其中功能相对POI比较弱一点。但jExcelAPI对中文支持非常好，API是纯Java的， 并不依赖Windows系统，即使运行在Linux下，它同样能够正确的处理Excel文件。 另外需要说明的是，这套API对图形和图表的支持很有限，而且仅仅识别PNG格式。

使用如下：

搭建环境

将下载后的文件解包，得到jxl.jar，放入classpath，安装就完成了。

基本操作

一、创建文件

拟生成一个名为“test.xls”的Excel文件，其中第一个工作表被命名为
“第一页”，大致效果如下：
Java代码
package  test;  
 
// 生成Excel的类   
import  java.io.File;  
 
import  jxl.Workbook;  
import  jxl.write.Label;  
import  jxl.write.WritableSheet;  
import  jxl.write.WritableWorkbook;  
 
public   class  CreateExcel   {  
    public   static   void  main(String args[])   {  
        try    {  
            //  打开文件   
            WritableWorkbook book  =  Workbook.createWorkbook( new  File( " test.xls " ));  
            //  生成名为“第一页”的工作表，参数0表示这是第一页   
            WritableSheet sheet  =  book.createSheet( " 第一页 " ,  0 );  
            //  在Label对象的构造子中指名单元格位置是第一列第一行(0,0)  
            //  以及单元格内容为test   
            Label label  =   new  Label( 0 ,  0 ,  " test " );  
 
            //  将定义好的单元格添加到工作表中   
            sheet.addCell(label);  
 
            /**/ /*  
            * 生成一个保存数字的单元格 必须使用Number的完整包路径，否则有语法歧义 单元格位置是第二列，第一行，值为789.123 
             */   
           jxl.write.Number number  =   new  jxl.write.Number( 1 ,  0 ,  555.12541 );  
           sheet.addCell(number);  
 
            //  写入数据并关闭文件   
            book.write();  
           book.close();  
 
       }   catch  (Exception e)   {  
           System.out.println(e);  
       }   
   }   
   

 package  test;

 // 生成Excel的类
 import  java.io.File;

 import  jxl.Workbook;
 import  jxl.write.Label;
 import  jxl.write.WritableSheet;
 import  jxl.write.WritableWorkbook;

 public   class  CreateExcel   {
     public   static   void  main(String args[])   {
         try    {
             //  打开文件
             WritableWorkbook book  =  Workbook.createWorkbook( new  File( " test.xls " ));
             //  生成名为“第一页”的工作表，参数0表示这是第一页
             WritableSheet sheet  =  book.createSheet( " 第一页 " ,  0 );
             //  在Label对象的构造子中指名单元格位置是第一列第一行(0,0)
             //  以及单元格内容为test
             Label label  =   new  Label( 0 ,  0 ,  " test " );

             //  将定义好的单元格添加到工作表中
             sheet.addCell(label);

             /**/ /*
             * 生成一个保存数字的单元格 必须使用Number的完整包路径，否则有语法歧义 单元格位置是第二列，第一行，值为789.123
              */
            jxl.write.Number number  =   new  jxl.write.Number( 1 ,  0 ,  555.12541 );
            sheet.addCell(number);

             //  写入数据并关闭文件
             book.write();
            book.close();

        }   catch  (Exception e)   {
            System.out.println(e);
        }
    }
}
 

   编译执行后，会产生一个Excel文件。

三、读取文件

以刚才我们创建的Excel文件为例，做一个简单的读取操作，程序代码如下：
Java代码
package  test;  
 
// 读取Excel的类   
import  java.io.File;  
 
import  jxl.Cell;  
import  jxl.Sheet;  
import  jxl.Workbook;  
 
public   class  ReadExcel   {  
    public   static   void  main(String args[])   {  
        try    {  
           Workbook book  =  Workbook.getWorkbook( new  File( " test.xls " ));  
            //  获得第一个工作表对象   
            Sheet sheet  =  book.getSheet( 0 );  
            //  得到第一列第一行的单元格   
            Cell cell1  =  sheet.getCell( 0 ,  0 );  
           String result  =  cell1.getContents();  
           System.out.println(result);  
           book.close();  
       }   catch  (Exception e)   {  
           System.out.println(e);  
       }   
   }   
   

 package  test;

 // 读取Excel的类
 import  java.io.File;

 import  jxl.Cell;
 import  jxl.Sheet;
 import  jxl.Workbook;

 public   class  ReadExcel   {
     public   static   void  main(String args[])   {
         try    {
            Workbook book  =  Workbook.getWorkbook( new  File( " test.xls " ));
             //  获得第一个工作表对象
             Sheet sheet  =  book.getSheet( 0 );
             //  得到第一列第一行的单元格
             Cell cell1  =  sheet.getCell( 0 ,  0 );
            String result  =  cell1.getContents();
            System.out.println(result);
            book.close();
        }   catch  (Exception e)   {
            System.out.println(e);
        }
    }
}
 

  程序执行结果：test

四、修改文件
利用jExcelAPI可以修改已有的Excel文件，修改Excel文件的时候，除了打开文件的方式不同之外，
其他操作和创建Excel是一样的。下面的例子是在我们已经生成的Excel文件中添加一个工作表：
Java代码
package  test;  
 
import  java.io.File;  
 
import  jxl.Workbook;  
import  jxl.write.Label;  
import  jxl.write.WritableSheet;  
import  jxl.write.WritableWorkbook;  
 
public   class  UpdateExcel   {  
    public   static   void  main(String args[])   {  
        try    {  
            //  Excel获得文件   
            Workbook wb  =  Workbook.getWorkbook( new  File( " test.xls " ));  
            //  打开一个文件的副本，并且指定数据写回到原文件   
            WritableWorkbook book  =  Workbook.createWorkbook( new  File( " test.xls " ),  
                   wb);  
            //  添加一个工作表   
            WritableSheet sheet  =  book.createSheet( " 第二页 " ,  1 );  
           sheet.addCell( new  Label( 0 ,  0 ,  " 第二页的测试数据 " ));  
           book.write();  
           book.close();  
       }   catch  (Exception e)   {  
           System.out.println(e);  
       }   
   }   
   

 package  test;

 import  java.io.File;

 import  jxl.Workbook;
 import  jxl.write.Label;
 import  jxl.write.WritableSheet;
 import  jxl.write.WritableWorkbook;

 public   class  UpdateExcel   {
     public   static   void  main(String args[])   {
         try    {
             //  Excel获得文件
             Workbook wb  =  Workbook.getWorkbook( new  File( " test.xls " ));
             //  打开一个文件的副本，并且指定数据写回到原文件
             WritableWorkbook book  =  Workbook.createWorkbook( new  File( " test.xls " ),
                    wb);
             //  添加一个工作表
             WritableSheet sheet  =  book.createSheet( " 第二页 " ,  1 );
            sheet.addCell( new  Label( 0 ,  0 ,  " 第二页的测试数据 " ));
            book.write();
            book.close();
        }   catch  (Exception e)   {
            System.out.println(e);
        }
    }
}
 

其他操作

一、 数据格式化

在Excel中不涉及复杂的数据类型，能够比较好的处理字串、数字和日期已经能够满足一般的应用。

1、 字串格式化

字符串的格式化涉及到的是字体、粗细、字号等元素，这些功能主要由WritableFont和
WritableCellFormat类来负责。假设我们在生成一个含有字串的单元格时，使用如下语句，
为方便叙述，我们为每一行命令加了编号：
Java代码
WritableFont font1 =   
 new  WritableFont(WritableFont.TIMES, 16 ,WritableFont.BOLD); ①  
 
WritableCellFormat format1 = new  WritableCellFormat(font1); ②  
 
Label label = new  Label( 0 , 0 ,”data  4  test”,format1) ③  
 
 
 其中①指定了字串格式：字体为TIMES，字号16，加粗显示。WritableFont有非常丰富的  
构造子，供不同情况下使用，jExcelAPI的java-doc中有详细列表，这里不再列出。  
 
②处代码使用了WritableCellFormat类，这个类非常重要，通过它可以指定单元格的各种  
属性，后面的单元格格式化中会有更多描述。  
 
③处使用了Label类的构造子，指定了字串被赋予那种格式。  
 
在WritableCellFormat类中，还有一个很重要的方法是指定数据的对齐方式，比如针对我们  
上面的实例，可以指定：  
 
  // 把水平对齐方式指定为居中   
 format1.setAlignment(jxl.format.Alignment.CENTRE);  
 
 // 把垂直对齐方式指定为居中   
 format1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);  

 WritableFont font1 =
  new  WritableFont(WritableFont.TIMES, 16 ,WritableFont.BOLD); ①

 WritableCellFormat format1 = new  WritableCellFormat(font1); ②

 Label label = new  Label( 0 , 0 ,”data  4  test”,format1) ③

 
  其中①指定了字串格式：字体为TIMES，字号16，加粗显示。WritableFont有非常丰富的
 构造子，供不同情况下使用，jExcelAPI的java-doc中有详细列表，这里不再列出。

 ②处代码使用了WritableCellFormat类，这个类非常重要，通过它可以指定单元格的各种
 属性，后面的单元格格式化中会有更多描述。

 ③处使用了Label类的构造子，指定了字串被赋予那种格式。

 在WritableCellFormat类中，还有一个很重要的方法是指定数据的对齐方式，比如针对我们
 上面的实例，可以指定：

   // 把水平对齐方式指定为居中
  format1.setAlignment(jxl.format.Alignment.CENTRE);

  // 把垂直对齐方式指定为居中
  format1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);
 
二、单元格操作

Excel中很重要的一部分是对单元格的操作，比如行高、列宽、单元格合并等，所幸jExcelAPI
提供了这些支持。这些操作相对比较简单，下面只介绍一下相关的API。

1、 合并单元格
Java代码
WritableSheet.mergeCells( int  m, int  n, int  p, int  q);   
 
// 作用是从(m,n)到(p,q)的单元格全部合并，比如：   
WritableSheet sheet = book.createSheet(“第一页”, 0 );  
 
// 合并第一列第一行到第六列第一行的所有单元格   
sheet.mergeCells( 0 , 0 , 5 , 0 );  

  WritableSheet.mergeCells( int  m, int  n, int  p, int  q);

  // 作用是从(m,n)到(p,q)的单元格全部合并，比如：
  WritableSheet sheet = book.createSheet(“第一页”, 0 );

  // 合并第一列第一行到第六列第一行的所有单元格
  sheet.mergeCells( 0 , 0 , 5 , 0 );
 
合并既可以是横向的，也可以是纵向的。合并后的单元格不能再次进行合并，否则会触发异常。

2、 行高和列宽
Java代码
 WritableSheet.setRowView( int  i, int  height);  
 
 // 作用是指定第i+1行的高度，比如：  
 
 // 将第一行的高度设为200   
 sheet.setRowView( 0 , 200 );  
 
WritableSheet.setColumnView( int  i, int  width);  
 
 // 作用是指定第i+1列的宽度，比如：  
 
 // 将第一列的宽度设为30   
 sheet.setColumnView( 0 , 30 );  
   
  

  WritableSheet.setRowView( int  i, int  height);

  // 作用是指定第i+1行的高度，比如：

  // 将第一行的高度设为200
  sheet.setRowView( 0 , 200 );

 WritableSheet.setColumnView( int  i, int  width);

  // 作用是指定第i+1列的宽度，比如：

  // 将第一列的宽度设为30
  sheet.setColumnView( 0 , 30 );
 
 

jExcelAPI还有其他的一些功能，比如插入图片等，这里就不再一一介绍，读者可以自己探索。

其中：如果读一个excel，需要知道它有多少行和多少列，如下操作：
Java代码
Workbook book  =  Workbook.getWorkbook( new  File( " 测试1.xls " ));  
        //  获得第一个工作表对象   
        Sheet sheet  =  book.getSheet( 0 );  
        //  得到第一列第一行的单元格   
         int  columnum  =  sheet.getColumns(); //  得到列数   
         int  rownum  =  sheet.getRows(); //  得到行数   
        System.out.println(columnum);  
       System.out.println(rownum);  
        for  ( int  i  =   0 ; i  <  rownum; i ++ ) //  循环进行读写   
           {  
            for  ( int  j  =   0 ; j  <  columnum; j ++ )   {  
               Cell cell1  =  sheet.getCell(j, i);  
               String result  =  cell1.getContents();  
               System.out.print(result);  
               System.out.print( " \t " );  
           }   
           System.out.println();  
       }   
       book.close();  

　　谈及Java反射机制就一定要知道一个名为“Class”的类，它是Java反射机制的基础。“Class”和其它类一样继承于Object类，它的实例对象用来描述Java运行时的一种类型，接口，或者原始类型(比如int).“Class”的实例要由JVM创建，它没有公用的构造方法。下面我们来看一下如何获得"Class"类实例。

　　主要有三种方法。

　　一，通过Class类的静态方法forName获取。Class cla = Class.forName("java.lang.String");

　　二，通过.Type或.class属性获得。Class cla = String.class;Class cla1 = int.Type;

　　三，通过实例变量的getClass方法获得。String s = ""; Class cla = s.getClass();

　　如上所示实例对象cla就是对String类型的描述，通过它我们就可以创建一个String实例，并调用其中的方法。下一篇我将通过一个例子来展示如何使用Java反射机制。

　　Camera接口：定义了takePhoto()方法。

　　Camera01类：一种照相机的类型，实现Camera接口。

　　Camera02类：另一种照相机的类型，实现Camera接口。

　　Seller类：卖照相机。

　　Customer类：买相机，有main方法。

　　所有类都放在com包里

　　程序如下：

　　public interface Camera {

　　//声明照相机必须可以拍照

　　public void takePhoto();

　　}

　　public class Camera01 implements Camera {

　　private final int prefixs =300;//300万象素

　　private final double ptionZoom=3.5; //3.5倍变焦

　　public void takePhoto() {

　　System.out.println("Camera01 has taken a photo");

　　}

　　}

　　类似的有

　　public class Camera02 implements Camera {

　　private final int prefixs =400;

　　private final double ptionZoom=5;

　　public void takePhoto() {

　　System.out.println("Camera02 has taken a photo");

　　}

　　}

　　顾客出场了

　　public class Customer {

　　public static void main(String[] args){

　　//找到一个售货员

　　Seller seller = new Seller();

　　//向售货员询问两种相机的信息

　　seller.getDescription("com.Camera01");

　　seller.getDescription("com.Camera02");

　　//觉得Camera02比较好，叫售货员拿来看

　　Camera camera =(Camera)seller.getCamera("com.Camera02");

　　//让售货员拍张照试一下

　　seller.testFuction(camera, "takePhoto");

　　}

　　}

　　Seller类通过Java反射机制实现

　　import java.lang.reflect.Field;

　　import java.lang.reflect.Method;

　　public class Seller {

　　//向顾客描述商品信息

　　public void getDescription(String type){

　　try {

　　Class cla = Class.forName(type);

　　//生成一个实例对象，在编译时我们并不知道obj是什么类型。

　　Object bj = cla.newInstance();

　　//获得type类型所有已定义类变量及方法。

　　Field[] fileds = cla.getDeclaredFields();

　　Method[]methods = cla.getDeclaredMethods();

　　System.out.println("The arguments of this Camera is:");

　　for(int i=0;i

　　fileds[i].setAccessible(true);

　　//输出类变量的定义及obj实例中对应的值

　　System.out.println(fileds[i]+":"+fileds[i].get(obj));

　　}

　　System.out.println("The function of this Camera:");

　　for(int i=0;i

　　//输出类中方法的定义

　　System.out.println(methods[i]);

　　}

　　System.out.println();

　　} catch (Exception e) {

　　System.out.println("Sorry , no such type");

　　}

　　}

　　//使用商品的某个功能

　　public void testFuction(Object obj,String function){

　　try {

　　Class cla = obj.getClass();

　　//获得cla类中定义的无参方法。

　　Method m = cla.getMethod(function, null);

　　//调用obj中名为function的无参方法。

　　m.invoke(obj, null);

　　} catch (Exception e) {

　　System.out.println("Sorry , no such function");

　　}

　　}

　　//拿商品给顾客

　　public Object getCamera(String type){

　　try {

　　Class cla = Class.forName(type);

　　Object bj = cla.newInstance();

　　return obj;

　　} catch (Exception e) {

　　System.out.println("Sorry , no such type");

　　return null;

　　}

　　}

　　}

　　首先，获得StringBuffer类的描述。

　　Class cla = Class.forName("java.lang.StringBuffer");

　　其次，要创建参数类型数组Class[] 。

　　Class[] paraTypes = new Class[1];paraTypes[0]=String.class;

　　然后，通过cla 和 paraTypes 获得Constructor 对象。

　　Constructor constructor = cla.getConstructor(paraTypes);

　　接着，创建传入的参数列表Object[]。

　　Object[] paraLists = new Object[1]; paraLists[0]="color";

　　最后，得到我们所要得对象。Object bj = constructor.newInstance(paraLists);

　　如果我们paraTypes及paraLists设为null或长度为0，就可以用上述步骤调用StringBuffer的无参构造方法。类似地，我们可以调用对象中的有参方法。比如我们做如下操作br.insert(4, 'u');用反射机制实现如下。

　　Class[] paratypes = new Class[]{int.class,char.class};

　　Method method = cla.getMethod("insert", paratypes);

　　Object[] paralists = new Object[]{4,'u'};

　　method.invoke(obj, paralists);

　　反射机制给予我们运行时才确定对象类型的便利，然而它也有显著的缺点。

　　1，代码笨拙冗长。比如本来一句br.insert(4, 'u');可以解决的问题现在要用到四句。

　　2，损失了编译时类型检查的好处。这使得你要对付更多的异常。

　　3，性能损失。用反射机制运行的时间更久。

　　<>中给出的建议是“普通应用不应在运行时刻以映像方式访问对象，只是在很有限的情况下使用“。那么在什么地方会用到反射机制呢。已有的较熟悉应用是我们的IDE及一些框架。比如eclipse,编程时ctrl+space弹出的建议就是用到反射机制。比如Spring读取配置文件后生成对应的对象。还有RPC系统也会用到。对于一般的应用软件，你可以在工厂方法中用到它。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类， Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的 Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object bj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。

List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

Stack 类
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得 Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。

HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

同步性
Vector 是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。

数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度， ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用 Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

使用模式
在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用 O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？

这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用 ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。

最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

Java 中 Vector、ArrayList、List 使用深入剖析 - 程序杂烩