线程池的原理 精简了一下便于大家理解

public class threadPool {
            //线程池中默认的个数
private static int worker_num=5;
//工作线程
private workThread[] workThrads;

//任务队列 作为一个缓冲 ，list线程不安全
private List<Runnable> taskQueue=new LinkedList<Runnable>();
//未处理的任务
private static volatile int finished_task=0;

private static threadPool threadPool;




    //单台模式获得一个指定线程个数的线程池，
private static threadPool gettThreadPool(int worker_num1) {
    if(worker_num1<=0)
worker_num1=threadPool.worker_num;
    if(threadPool==null)
    threadPool=new threadPool(worker_num1);
return threadPool;
}

//创建线程池
public threadPool(int worker_num) {
threadPool.worker_num=worker_num;
workThrads=new workThread[worker_num];
for(int i=0;i<worker_num;i++){
workThrads[i]=new workThread();
workThrads[i].start();
}
}

//批量执行任务，其实只是把任务加入任务队列，什么时候执行有线程池管理器决定
    public void execute(Runnable[] task){
    synchronized(taskQueue){
    for(Runnable t: task)
    taskQueue.add(t);
    taskQueue.notify();
    }
    }
    
//内部类，工作线程
private class workThread extends Thread{
private boolean isRunning=true;
public void run(){

Runnable r=null;
while(isRunning){
synchronized(taskQueue){
while(isRunning&&taskQueue.isEmpty()){
try {
taskQueue.wait(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(!taskQueue.isEmpty())
r=taskQueue.remove(0);//取出任务

}
if(r!=null){
r.run();
}
finished_task++;
r=null;
}
}

//停止工作，让线程自然执行run方法自然结束
public void stopWorker(){
isRunning=false;
}

}
    //销毁线程池
public void destroy(){
while(!taskQueue.isEmpty()){// 如果还有任务没执行完成，就先睡会吧 
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//工作线程停止工作，且置为null
for(int i=0;i<worker_num;i++){
workThrads[i].stopWorker();
workThrads[i]=null;
}
threadPool=null;
taskQueue.clear();// 清空任务队列 

}


   
static class Task implements Runnable{
private static volatile int i=1;
public void run(){
System.out.println("任务"+(i++)+"完成");
}
}

public static void main(String[] args) {
threadPool t = threadPool.gettThreadPool(3);
t.execute(new Runnable[]{new Task(),new Task(),new Task()});
t.execute(new Runnable[]{new Task(),new Task(),new Task()});
         System.out.println(t);
         t.destroy();
         System.out.println(t);
}

public String toString(){
   return "工作线程数量:"+worker_num+"完成任务数量："+finished_task+"等待任务数量："+taskQueue.size();
    }


/*private threadPool(){
this(5);
}*/


 /*//单态模式
public static threadPool gettThreadPool(){
return gettThreadPool(threadPool.worker_num);
}*/

     /* //执行任务，其实只是把任务加入任务队列，什么时候执行有线程池管理器决定
public void execute(Runnable task){
synchronized(taskQueue){
taskQueue.add(task);
taskQueue.notify();
}
}*/


  /*//批量执行任务，其实只是把任务加入任务队列，什么时候执行有线程池管理器决定
    public void execute(List<Runnable> task){
    synchronized(taskQueue){
    for(Runnable t: task)
    taskQueue.add(t);
    taskQueue.notify();
    }
    }*/
    
    // 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁  

/*// 返回工作线程的个数  
      public int getWorkThreadNumber(){
return worker_num;
      }
      // 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成  
      public int getFinishedTaskumber(){
  return finished_task;
        }
      // 返回任务队列的长度，即还没处理的任务个数 
      public int getWaitTasknumber(){
     return taskQueue.size();
      }*/


      
      




}