1、谁创建线程？
　　即使您从未显式地创建一个新线程，您仍可能会发现自己在使用线程。线程被从各种来源中引入到我们的程序中。
　　有许多工具可以为您创建线程，如果要使用这些工具，应该了解线程如何交互，以及如何防止线程互相干扰。
　　2、AWT 和 Swing
　　任何使用 AWT 或 Swing 的程序都必须处理线程。AWT 工具箱创建单个线程，用于处理 UI 事件，任何由 AWT 事件调用的事件侦听器都在 AWT 事件线程中执行。
　　您不仅必须关心同步对事件侦听器和其它线程之间共享的数据项的访问，而且还必须找到一种方法，让由事件侦听器触发的长时间运行任务（如在大文档中检查拼写或在文件系统中搜索一个文件） 在后台线程中运行，这样当该任务运行时，UI 就不会停滞了（这可能还会阻止用户取消操作）。这样做的一个好的框架示例是 SwingWorker 类
　　AWT 事件线程并不是守护程序线程；这就是通常使用 System.exit() 结束 AWT 和 Swing 应用程序的原因。
　　3、使用 TimerTask
　　JDK 1.3 中，TimerTask 工具被引入到 Java 语言。这个便利的工具让您可以稍后在某个时间执行任务（例如，即从现在起十秒后运行一次任务），或者定期执行任务（即，每隔十秒运行任务）。
　　实现 Timer 类非常简单：它创建一个计时器线程，并且构建一个按执行时间排序的等待事件队列。
　　TimerTask 线程被标记成守护程序线程，这样它就不会阻止程序退出。
　　因为计时器事件是在计时器线程中执行，所以必须确保正确同步了针对计时器任务中使用的任何数据项的访问。
　　在 CalculatePrimes 示例中，并没有让主线程休眠，我们可以使用 TimerTask，方法如下：
　　 public static void main(String[] args) {
　　 Timer timer = new Timer();
　　 final CalculatePrimes calculator = new CalculatePrimes();
　　 calculator.start();
　　 timer.schedule(
　　 new TimerTask() {
　　 public void run()
　　 {
　　 calculator.finished = true;
　　 }
　　 }, TEN_SECONDS);
　　 }
　　4、servlet 和 JavaServer Pages 技术
　　servlet 容器创建多个线程，在这些线程中执行 servlet 请求。作为 servlet 编写者，您不知道（也不应该知道）您的请求会在什么线程中执行；如果同时有多个对相同 URL 的请求入站，那么同一个 servlet 可能会同时在多个线程中是活动的。
　　当编写 servlet 或 JavaServer Pages (JSP) 文件时，必须始终假设可以在多个线程中并发地执行同一个 servlet 或 JSP 文件。必须适当同步 servlet 或 JSP 文件访问的任何共享数据；这包括 servlet 对象本身的字段。
　　5、实现 RMI 对象
　　RMI 工具可以让您调用对在其它 JVM 中运行的对象进行的操作。当调用远程方法时，RMI 编译器创建的 RMI 存根会打包方法参数，并通过网络将它们发送到远程系统，然后远程系统会将它们解包并调用远程方法。
　　假设您创建了一个 RMI 对象，并将它注册到 RMI 注册表或者 Java 命名和目录接口（Java Naming and Directory Interface (JNDI)）名称空间。当远程客户机调用其中的一个方法时，该方法会在什么线程中执行呢？
　　实现 RMI 对象的常用方法是继承 UnicastRemoteObject。在构造 UnicastRemoteObject 时，会初始化用于分派远程方法调用的基础结构。这包括用于接收远程调用请求的套接字侦听器，和一个或多个执行远程请求的线程。
　　所以，当接收到执行 RMI 方法的请求时，这些方法将在 RMI 管理的线程中执行。
　　6、小结
　　线程通过几种机制进入 Java 程序。除了用 Thread 构造器中显式创建线程之外，还可以用许多其它机制创建线程：
　　AWT 和 Swing
　　RMI
　　java.util.TimerTask 工具
　　servlet 和 JSP 技术

共享变量

1、 共享变量
　　要使多个线程在一个程序中有用，它们必须有某种方法可以互相通信或共享它们的结果。
　　让线程共享其结果的最简单方法是使用共享变量。它们还应该使用同步来确保值从一个线程正确传播到另一个线程，以及防止当一个线程正在更新一些相关数据项时，另一个线程看到不一致的中间结果。
　　线程基础中计算素数的示例使用了一个共享布尔变量，用于表示指定的时间段已经过去了。这说明了在线程间共享数据最简单的形式是：轮询共享变量以查看另一个线程是否已经完成执行某项任务。
　　2、存在于同一个内存空间中的所有线程
　　正如前面讨论过的，线程与进程有许多共同点，不同的是线程与同一进程中的其它线程共享相同的进程上下文，包括内存。这非常便利，但也有重大责任。只要访问共享变量（静态或实例字段），线程就可以方便地互相交换数据，但线程还必须确保它们以受控的方式访问共享变量，以免它们互相干扰对方的更改。
　　任何线程可以访问所有其作用域内的变量，就象主线程可以访问该变量一样。素数示例使用了一个公用实例字段，叫做 finished，用于表示已经过了指定的时间。当计时器过期时，一个线程会写这个字段；另一个线程会定期读取这个字段，以检查它是否应该停止。注：这个字段被声明成 volatile，这对于这个程序的正确运行非常重要。在本章的后面，我们将看到原因。
　　3、受控访问的同步
　　为了确保可以在线程之间以受控方式共享数据，Java 语言提供了两个关键字：synchronized 和 volatile。
　　Synchronized 有两个重要含义：它确保了一次只有一个线程可以执行代码的受保护部分（互斥，mutual exclusion 或者说 mutex），而且它确保了一个线程更改的数据对于其它线程是可见的（更改的可见性）。
　　如果没有同步，数据很容易就处于不一致状态。例如，如果一个线程正在更新两个相关值（比如，粒子的位置和速率），而另一个线程正在读取这两个值，有可能在第一个线程只写了一个值，还没有写另一个值的时候，调度第二个线程运行，这样它就会看到一个旧值和一个新值。同步让我们可以定义必须原子地运行的代码块，这样对于其他线程而言，它们要么都执行，要么都不执行。
　　同步的原子执行或互斥方面类似于其它操作环境中的临界段的概念。
　　4、确保共享数据更改的可见性
　　同步可以让我们确保线程看到一致的内存视图。
　　处理器可以使用高速缓存加速对内存的访问（或者编译器可以将值存储到寄存器中以便进行更快的访问）。在一些多处理器体系结构上，如果在一个处理器的高速缓存中修改了内存位置，没有必要让其它处理器看到这一修改，直到刷新了写入器的高速缓存并且使读取器的高速缓存无效。
　　这表示在这样的系统上，对于同一变量，在两个不同处理器上执行的两个线程可能会看到两个不同的值！这听起来很吓人，但它却很常见。它只是表示在访问其它线程使用或修改的数据时，必须遵循某些规则。
　　Volatile 比同步更简单，只适合于控制对基本变量（整数、布尔变量等）的单个实例的访问。当一个变量被声明成 volatile，任何对该变量的写操作都会绕过高速缓存，直接写入主内存，而任何对该变量的读取也都绕过高速缓存，直接取自主内存。这表示所有线程在任何时候看到的 volatile 变量值都相同。
　　如果没有正确的同步，线程可能会看到旧的变量值，或者引起其它形式的数据损坏。
　　5、用锁保护的原子代码块
　　Volatile 对于确保每个线程看到最新的变量值非常有用，但有时我们需要保护比较大的代码片段，如涉及更新多个变量的片段。
　　同步使用监控器（monitor）或锁的概念，以协调对特定代码块的访问。
　　每个 Java 对象都有一个相关的锁。同一时间只能有一个线程持有 Java 锁。当线程进入 synchronized 代码块时，线程会阻塞并等待，直到锁可用，当它可用时，就会获得这个锁，然后执行代码块。当控制退出受保护的代码块时，即到达了代码块末尾或者抛出了没有在 synchronized 块中捕获的异常时，它就会释放该锁。
　　这样，每次只有一个线程可以执行受给定监控器保护的代码块。从其它线程的角度看，该代码块可以看作是原子的，它要么全部执行，要么根本不执行。
　　6、简单的同步示例
　　使用 synchronized 块可以让您将一组相关更新作为一个集合来执行，而不必担心其它线程中断或看到计算的中间结果。以下示例代码将打印“1 0”或“0 1”。如果没有同步，它还会打印“1 1”（或“0 0”，随便您信不信）。
　　public class SyncExample {
　　 private static lockObject = new Object();
　　 private static class Thread1 extends Thread {
　　 public void run() {
　　 synchronized (lockObject) {
　　 x = y = 0;
　　 System.out.println(x);
　　 }
　　 }
　　 }
　　 private static class Thread2 extends Thread {
　　 public void run() {
　　 synchronized (lockObject) {
　　 x = y = 1;
　　 System.out.println(y);
　　 }
　　 }
　　 }
　　 public static void main(String[] args) {
　　 new Thread1().run();
　　 new Thread2().run();
　　 }
　　}
　　在这两个线程中都必须使用同步，以便使这个程序正确工作。
　　7、Java 锁定
　　Java 锁定合并了一种互斥形式。每次只有一个线程可以持有锁。锁用于保护代码块或整个方法，必须记住是锁的身份保护了代码块，而不是代码块本身，这一点很重要。一个锁可以保护许多代码块或方法。
　　反之，仅仅因为代码块由锁保护并不表示两个线程不能同时执行该代码块。它只表示如果两个线程正在等待相同的锁，则它们不能同时执行该代码。
　　在以下示例中，两个线程可以同时不受限制地执行 setLastAccess() 中的 synchronized 块，因为每个线程有一个不同的 thingie 值。因此，synchronized 代码块受到两个正在执行的线程中不同锁的保护。
　　public class SyncExample {
　　 public static class Thingie {
　　 private Date lastAccess;
　　 public synchronized void setLastAccess(Date date) {
　　 this.lastAccess = date;
　　 }
　　 }
　　 public static class MyThread extends Thread {
　　 private Thingie thingie;
　　 public MyThread(Thingie thingie) {
　　 this.thingie = thingie;
　　 }
　　 public void run() {
　　 thingie.setLastAccess(new Date());
　　 }
　　 }
　　 public static void main() {
　　 Thingie thingie1 = new Thingie(),
　　 thingie2 = new Thingie();
　　 new MyThread(thingie1).start();
　　 new MyThread(thingie2).start();
　　 }
　　}
　　8、同步的方法
　　创建 synchronized 块的最简单方法是将方法声明成 synchronized。这表示在进入方法主体之前，调用者必须获得锁：
　　public class Point {
　　 public synchronized void setXY(int x, int y) {
　　 this.x = x;
　　 this.y = y;
　　 }
　　}
　　对于普通的 synchronized方法，这个锁是一个对象，将针对它调用方法。对于静态 synchronized 方法，这个锁是与 Class 对象相关的监控器，在该对象中声明了方法。
　　仅仅因为 setXY() 被声明成 synchronized 并不表示两个不同的线程不能同时执行 setXY()，只要它们调用不同的 Point 实例的 setXY() 就可同时执行。对于一个 Point 实例，一次只能有一个线程执行 setXY()，或 Point 的任何其它 synchronized 方法。
　　9、同步的块
　　synchronized 块的语法比 synchronized 方法稍微复杂一点，因为还需要显式地指定锁要保护哪个块。Point 的以下版本等价于前一页中显示的版本：
　　public class Point {
　　 public void setXY(int x, int y) {
　　 synchronized (this) {
　　 this.x = x;
　　 this.y = y;
　　 }
　　 }
　　}
　　使用 this 引用作为锁很常见，但这并不是必需的。这表示该代码块将与这个类中的 synchronized 方法使用同一个锁。
　　由于同步防止了多个线程同时执行一个代码块，因此性能上就有问题，即使是在单处理器系统上。最好在尽可能最小的需要保护的代码块上使用同步。
　　访问局部（基于堆栈的）变量从来不需要受到保护，因为它们只能被自己所属的线程访问。
　　10、大多数类并没有同步
　　因为同步会带来小小的性能损失，大多数通用类，如 java.util 中的 Collection 类，不在内部使用同步。这表示在没有附加同步的情况下，不能在多个线程中使用诸如 HashMap 这样的类。

文章在这里

可参考：

http://www-900.ibm.com/developerWorks/cn/xml/x-injava/index.shtml
http://www-900.ibm.com/developerWorks/cn/xml/x-injava2/index.shtml

结论是：DOM4J是这场测试的获胜者，目前许多开源项目中大量采用 DOM4J

其实我认为归根结底就是两种技术：DOM和SAX
    DOM是一次性把XML读进内存，构造Document对象，然后可以以任何规则来解析文件，也可以做响应修改，处理比较灵活。但是DOM比较消耗内存，不能处理太大的文件。主流的DOM有JDOM，DOM4J；
    SAX是一个事件驱动的解析器，是逐句读文件，触发事件，执行操作。但是它只能解析，不能对XML文件修改。

　　下面是一些得到classpath和当前类的绝对路径的一些方法。你可能需要使用其中的一些方法来得到你需要的资源的绝对路径。

　　1.FileTest.class.getResource("")

　　得到的是当前类FileTest.class文件的URI目录。不包括自己！

　　如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/com/test/

　　2.FileTest.class.getResource("/")

　　得到的是当前的classpath的绝对URI路径。

　　如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

　　3.Thread.currentThread().getContextClassLoader().getResource("")

　　得到的也是当前ClassPath的绝对URI路径。

　　如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

　　4.FileTest.class.getClassLoader().getResource("")

　　得到的也是当前ClassPath的绝对URI路径。

　　如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

　　5.ClassLoader.getSystemResource("")

　　得到的也是当前ClassPath的绝对URI路径。

　　如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

　　我推荐使用Thread.currentThread().getContextClassLoader().getResource("")来得到当前的classpath的绝对路径的URI表示法。

    在Web应用程序中，我们一般通过ServletContext.getRealPath("/")方法得到Web应用程序的根目录的绝对路径。这样，我们只需要提供相对于Web应用程序根目录的路径，就可以构建出定位资源的绝对路径。
   
   

注意点：
    1.尽量不要使用相对于System.getProperty("user.dir")当前用户目录的相对路径。这是一颗定时炸弹，随时可能要你的命。

　　2.尽量使用URI形式 
的绝对路径资源。它可以很容易的转变为URI,URL，File对象。

　　3.尽量使用相对classpath的相对路径。不要使用绝对路径。使用上面ClassLoaderUtil类的public static URL getExtendResource(String relativePath)方法已经能够使用相对于classpath的相对路径定位所有位置的资源。

　　4.绝对不要使用硬编码的绝对路径。因为，我们完全可以使用ClassLoader类的getResource("")方法得到当前classpath的绝对路径。

使用硬编码的绝对路径是完全没有必要的！它一定会让你死的很难看！程序将无法移植！

　　如果你一定要指定一个绝对路径，那么使用配置文件，也比硬编码要好得多！

　　当然，我还是推荐你使用程序得到classpath的绝对路径来拼资源的绝对路径