如何判断线程池处理完任务

Question

用的是ThreadPoolExecutor,做法是提交一个任务后不管,可以提交多个任务.最后要等任务全部完成了在去调用一个方法,我原来的做法是:public boolean isEndTask() {
    while (true) {
      if (this.executor.getActiveCount() == 0) {
        return true;      }    }
  }
public   void synBackup(String fn, IProgress pro) {   if (isEndTask()) //如果线程池处理完毕,就干别的事情...,这个方法一定会返回true的.
{
....
  
}
}
也就是调用synBackup(String fn, IProgress pro)这个方法的时候,一定使线程池里面的任务完成了我才可以干其他的事情.
本来不用什么线程池,也就是单线程来处理这个任务只需要17秒的,可是我用线程池后居然需要18秒,郁闷,没有体现速度.
不知道是我这样判断任务处理完毕的方法不对,还是构造线程池的时候参数设置的不是很合理,请高手指教指教!!

Answer 1

你这个等待所有的任务都执行完的思路好像不太好啊！
你应该根据当前工作线程的执行与否，来判断是否执行下一个任务;比如：如例程3-6所示，ThreadPool类提供了线程池的一种实现方案
[code=Java
]package multithread2;
import java.util.LinkedList;
public class ThreadPool extends ThreadGroup 
{
   private boolean isClosed=false;     //线程池是否关闭
    private LinkedList<Runnable> workQueue;   //表示工作队列
    private static int threadPoolID;     //表示线程池ID
   private int threadID;      //表示工作线程ID  
   public ThreadPool(int poolSize) {    //poolSize指定线程池中的工作线程数目
      super("ThreadPool-" + (threadPoolID++));
     setDaemon(true);
     workQueue = new LinkedList<Runnable>();   //创建工作队列    for (int i=0; i<poolSize; i++)
      new WorkThread().start();     //创建并启动工作线程
}
/** 向工作队列中加入一个新任务，由工作线程去执行该任务 */
public synchronized void execute(Runnable task) {
     if (isClosed) {      //线程池被关则抛出IllegalStateException异常
         throw new   IllegalStateException();
     }
     if (task != null) {
       workQueue.add(task);
        notify();       //唤醒正在getTask()方法中等待任务的工作线程
      }
}  /** 从工作队列中取出一个任务，工作线程会调用此方法 */
protected synchronized Runnable getTask()throws InterruptedException{
      while (workQueue.size() == 0) 
      {
             if (isClosed)
                return null;
             wait();       //如果工作队列中没有任务，就等待任务
        }
             return workQueue.removeFirst();
}  /** 关闭线程池 */
public synchronized void close() {
       if (!isClosed) {
          isClosed = true;
          workQueue.clear();     //清空工作队列
           interrupt();        //中断所有的工作线程，该方法继承自ThreadGroup类
         }
}  /** 等待工作线程把所有任务执行完 */
public void join() {
       synchronized (this) {
          isClosed = true;
          notifyAll();       //唤醒还在getTask()方法中等待任务的工作线程
        }    
       Thread[] threads = new Thread[activeCount()];
       //enumerate()方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
        int count = enumerate(threads);  
       for (int i=0; i<count; i++) {    //等待所有工作线程运行结束
           try {
            threads[i].join();     //等待工作线程运行结束
           }catch(InterruptedException ex) { }
}
}  /**  内部类：工作线程  */
private class WorkThread extends Thread {
     public WorkThread() {//加入到当前ThreadPool线程组中
         super(ThreadPool.this,"WorkThread-" + (threadID++));
     }
     public void run() {
        while (!isInterrupted()) {  //isInterrupted()方法继承自Thread类，判断线程是否被中断
            Runnable task = null;
        try {       //取出任务
           task = getTask();
        }catch (InterruptedException ex){}        
       // 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
        if (task == null) return;       try { //运行任务，异常在catch代码块中捕获
           task.run();
       } catch (Throwable t) {
            t.printStackTrace();
       }}      
        //#while
}       //#run()
}       //#WorkThread类
}  [/code]

Answer 2

晕，显示格式出错了在ThreadPool类中定义了一个LinkedList类型的workQueue成员变量，它表示工作队列，用来存放线程池要执行的任务，每个任务都是Runnable实例。ThreadPool类的客户程序（利用ThreadPool来执行任务的程序）只要调用ThreadPool类的execute (Runnable task)方法，就能向线程池提交任务。在ThreadPool类的execute()方法中，先判断线程池是否已经关闭。如果线程池已经关闭，就不再接收任务，否则就把任务加入到工作队列中，并且唤醒正在等待任务的工作线程。
在ThreadPool类的构造方法中，会创建并启动若干工作线程，工作线程的数目由构造方法的参数poolSize决定。WorkThread类表示工作线程，它是ThreadPool类的内部类。工作线程从工作队列中取出一个任务，接着执行该任务，然后再从工作队列中取出下一个任务并执行它，如此反复。
工作线程从工作队列中取任务的操作是由ThreadPool类的getTask()方法实现的，它的处理逻辑如下：
 如果队列为空并且线程池已关闭，那就返回null，表示已经没有任务可以执行了；
 如果队列为空并且线程池没有关闭，那就在此等待，直到其他线程将其唤醒或者中断；
 如果队列中有任务，就取出第一个任务并将其返回。