在多线程大师Doug Lea的贡献下，在JDK1.5中加入了许多对并发特性的支持，例如：线程池。

一、简介
线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为：
              
    ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                long keepAliveTime, TimeUnit unit,
                BlockingQueue workQueue,
                RejectedExecutionHandler handler)
               

    corePoolSize：   线程池维护线程的最少数量
    maximumPoolSize：线程池维护线程的最大数量
    keepAliveTime：  线程池维护线程所允许的空闲时间
    unit：           线程池维护线程所允许的空闲时间的单位
    workQueue：      线程池所使用的缓冲队列
    handler：        线程池对拒绝任务的处理策略
   
    一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。
   
    当一个任务通过execute(Runnable)方法欲添加到线程池时：
   
    如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

    如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。

    如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

    如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
   
    也就是：处理任务的优先级为：
    核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
   
    当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
   
    unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
    NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
   
    workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue
   
    handler有四个选择：
    ThreadPoolExecutor.AbortPolicy()       
       抛出java.util.concurrent.RejectedExecutionException异常
    ThreadPoolExecutor.CallerRunsPolicy()  
       重试添加当前的任务，他会自动重复调用execute()方法
    ThreadPoolExecutor.DiscardOldestPolicy()
       抛弃旧的任务
    ThreadPoolExecutor.DiscardPolicy()     
       抛弃当前的任务

   
二、一般用法举例
//------------------------------------------------------------
//TestThreadPool.java
//package cn.simplelife.exercise;

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {

    private static int produceTaskSleepTime = 2;
    private static int consumeTaskSleepTime = 2000;
    private static int produceTaskMaxNumber = 10;
   
 public static void main(String[] args) {

        //构造一个线程池   
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
                TimeUnit.SECONDS, new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        for(int i=1;i<=produceTaskMaxNumber;i++){
            try {              
                //产生一个任务，并将其加入到线程池
                String task = "task@ " + i;
    System.out.println("put " + task);
    threadPool.execute(new ThreadPoolTask(task));
    
    //便于观察，等待一段时间
                Thread.sleep(produceTaskSleepTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 }

 /**
  * 线程池执行的任务
  * @author hdpan
  */
    public static class ThreadPoolTask implements Runnable,Serializable{
     private static final long serialVersionUID = 0;
     //保存任务所需要的数据
        private Object threadPoolTaskData;
       
        ThreadPoolTask(Object tasks){
            this.threadPoolTaskData = tasks;
        }
        public void run(){
            //处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
   System.out.println("start .."+threadPoolTaskData);
         try {
             ////便于观察，等待一段时间
                Thread.sleep(consumeTaskSleepTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
            threadPoolTaskData = null;
        }
        public Object getTask(){
            return this.threadPoolTaskData;
        }
    }
}
//------------------------------------------------------------
说明：
1、在这段程序中，一个任务就是一个Runnable类型的对象，也就是一个ThreadPoolTask类型的对象。

2、一般来说任务除了处理方式外，还需要处理的数据，处理的数据通过构造方法传给任务。

3、在这段程序中，main()方法相当于一个残忍的领导，他派发出许多任务，丢给一个叫 threadPool的任劳任怨的小组来做。

    这个小组里面队员至少有两个，如果他们两个忙不过来， 任务就被放到任务列表里面。

    如果积压的任务过多，多到任务列表都装不下(超过3个)的时候，就雇佣新的队员来帮忙。但是基于成本的考虑，不能雇佣太多的队员， 至多只能雇佣 4个。

    如果四个队员都在忙时，再有新的任务， 这个小组就处理不了了，任务就会被通过一种策略来处理，我们的处理方式是不停的派发， 直到接受这个任务为止(更残忍！呵呵)。

    因为队员工作是需要成本的，如果工作很闲，闲到 3SECONDS都没有新的任务了，那么有的队员就会被解雇了，但是，为了小组的正常运转，即使工作再闲，小组的队员也不能少于两个。

4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制， 改变这两个值就可以观察不同速率下程序的工作情况。

5、通过调整4中所指的数据，再加上调整任务丢弃策略， 换上其他三种策略，就可以看出不同策略下的不同处理方式。

6、对于其他的使用方法，参看jdk的帮助，很容易理解和使用。

ClassName是这个Class的名称，这里假设为MyClass，处于MyPackage.MyChildPackage包中，如果你将source.props文件放在Classes文件夹中的时候，可以这样写ClassName.class.getResourceAsStream(/source.props)

如果你想把props文件放在包中的时候，假设放到MyPackage.MyChildPackage中的res文件夹，可以这样写ClassName.class.getResourceAsStream(/MyPackage/MyChildPackage/res/source.props)，/代表的是包的.

• form.htm

<html> 

<head> 

<title>档案上传</title> 

<meta http-equiv="Content-Type"

content="text/html; charset=Big5"> 

</head> 

<body> 

<b>档案上传</b></font></p>



<form name="UploadForm" 

enctype="multipart/form-data" 

method="post" action="upload.jsp"> 

<input type="file" name="File1" size="20" maxlength="20"> 

<br> 

<input type="file" name="File2" size="20" maxlength="20">    

<br> 

<input type="submit"value="上传"> 

</form>



</body> 

</html> 

• upload.jsp

<%@page import="com.oreilly.servlet.MultipartRequest" %> 

<% 

String saveDirectory = "/home/caterpillar/files/"; 

// 限制上传之档案大小为 5 MB 

int maxPostSize = 5 * 1024 * 1024 ; 

MultipartRequest multi = new MultipartRequest(request , 

saveDirectory , maxPostSize, "MS950"); 

out.println("档案上传OK"); 

%> 

打开eclipse,选择Window--Preferences...在对话框左边的树上双击Java，再双击Installed JREs，在右边选择前面有对勾的JRE，再单击右边的“Edit”按钮，
出现一个 Edit JRE 的对话框，在其中的Default VM Arguments: 框中输入 -Xms128m -Xmx512m ,这样设置Java拟虚机内存使用最小是128M，最大是512M，再单击“OK”关闭 Edit JRE 对话框，再单击“OK”关闭 Preferences对话框，Eclipse一下子就运行快了起来，呵~
或者是
可以在eclipse.ini文件中将默认设置改为-vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M或者更大，这要看你自己机器的内存配置而定，如果这样解决不了就右击eclipse快捷方式，在属性---快捷方式标签下---目标中输入E:\eclipse-SDK-3.2RC7-win32\eclipse\eclipse.exe -clean -vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M其中E:\eclipse-SDK-3.2RC7-win32\eclipse\eclipse.exe是我的eclipse的位置，就可以了

再一种情况就是看看电脑是不是安装了什么恶意插件！把它们都清楚掉就可以了！

3.内存插件

eclipse加速插件keepresident   http://suif.stanford.edu/pub/keepresident 

.eclipse加速插件keepresident   http://suif.stanford.edu/pub/keepresident  如果你的machine内存少于700m,那么该插件实在能让你的eclipse快起来,不再像以前那样,动不动就僵住了.  其原理是利用两个 windows api - setprocessworkingsetsize 与 virtuallock,实得windows操作系统尽量不把  java进程的内存pageout到硬盘,多hold住一些物理内存给java进程使用.这样当java process定期垃圾回收时就  不会表现得僵住了.

public class test {
public static void main(String[] args) {
String str=”F[ACE=color]dddddddddddddd[/FACE]“;
str=str.replaceAll(”[”,”<”);
System.out.print(str);
}
}
就在那个”[”这里出现错啦！
java.util.regex.PatternSyntaxException: Unclosed character class near
index 0
————————————————————————————————
String的replaceAll方法，第一个参数使用的是正则式表达方法。详细可看JDK文档。
上例改为replaceAll(”\\Q[\\E”,”<”);

public class PathTrackle

{
 public static String  existPathTrackle(String path){
  String  tempString = path.replaceAll("\\\\", "/");
  String returnString = tempString.replaceAll("/+|", "/");
  return returnString;
 }
 
  public static void main(String args[]){
   
    String a="ab/cd/";
    String b="\\\\\\dawson\\\\";
    String c="/////////////c/d//ab//kk//";
    System.out.println(existPathTrackle(c));
  }

}

public class TestVariableArg
{

  /**
   * @param args
   */
 
  public static String executeToW3CNodeArray (String query, Object... objectarray){
       System.out.println("executeToW3CNodeArray ");
       System.out.println("objectarray "+objectarray.toString());
       return query;
  }
  public static void main(String[] args)
  {
    Object a=(Object)"string ";
    System.out.println(executeToW3CNodeArray("Tapestry in Action"));

  }

}

    找到eclipse下的插件，叫jadclipse，安装好之后，只要双击。class文件，就能直接看源文件，包括jar

    包中的class文件，也可以直接反编译。

    1.下载http://www.kpdus.com/jad.html#download下载后解压。解压缩后将jad.exe拷贝到JRE的bin目录下，如\Java\jre1.5.0_06\bin

    2.下载 jadclipse_3.3.jar

    http://jaist.dl.sourceforge.net/sourceforge/jadclipse/net.sf.jadclipse_3.3.0.jar将jadclipse_3.1.0.jar复制到D：\Program Files\eclipse\myplugin\eclipse\plugins目录下（用的是

    link方式安装插件的）。

    3.启动Eclipse后，在Windows——>Perference——>Java下面应该会多出一个JadClipse目录，相关的设置可

    以在此修改配置jadclipse：设置path to decompiler为jad.exe的全路径，如：F：\Java\jre1.5.0_06\bin\jad.exe

    ，在Directory for temporary files中指定临时文件的路径，如：G：\Java\eclipse-SDK-3.0-win32\temp 4、在Eclipse的Windows——>Perference——>General->Editors->File Associations中修改“*.class”默

    认关联的编辑器为“JadClipse Class File Viewer”