线程池的简单实现

package com.mzsx.concurrent.threadpool;
import java.util.List;
import java.util.Vector;
public class ThreadPool {
 private static ThreadPool instance=null;
 //空闲的线程队列
 private List<PThread> idleThreads;
 //已有的线程总数
 private int threadCounter;
 private boolean isShutdown;
 
 private ThreadPool(){
  this.idleThreads=new Vector<PThread>(5);
  threadCounter=0;
 }
 
 public int getCreatedThreadsCount(){
  return threadCounter;
 }
 //取得线程池的实例
 public synchronized static ThreadPool getInstance(){
  if (instance==null) {
   instance=new ThreadPool();
  }
  return instance;
 }
 
 //放入线程池
 protected synchronized void repool(PThread repoolingThread){
  if (!isShutdown) {
   idleThreads.add(repoolingThread);
  }else{
   repoolingThread.shutdown();
  }
  
 }
 
 //停止线程池中所有的线程
 public synchronized void shutDown(){
  isShutdown=true;
  for (int i = 0; i < idleThreads.size(); i++) {
   PThread idleThread=(PThread)idleThreads.get(i);
   idleThread.shutdown();
  }
  
 }
 //执行任务
 public synchronized void start(Runnable target){
  PThread thread=null;
  //如果有空闲的线程，则直接使用
  if (idleThreads.size()>0) {
   int lastIndex=idleThreads.size()-1;
   thread=idleThreads.get(lastIndex);
   //立即执行这个任务
   thread.setTarget(target);
 
  }else {
   threadCounter++;
   //创建新线程
   thread  =new PThread(target, "PThread#"+threadCounter, this);
   thread.start();
  }
 }
}

package com.mzsx.concurrent.threadpool;
public class PThread extends Thread {
 //线程池
 private ThreadPool pool;
 //任务
 private Runnable target;
 private boolean isSHutdown=false;
 private boolean isIdle=false;
 public PThread(Runnable target,String name,ThreadPool pool){
  super(name);
  this.pool=pool;
  this.target=target;
 }
 public ThreadPool getPool() {
  return pool;
 }
 public void setPool(ThreadPool pool) {
  this.pool = pool;
 }
 public Runnable getTarget() {
  return target;
 }
 public synchronized void setTarget(Runnable newTarget) {
  target = newTarget;
  notifyAll();
 }
 public boolean isSHutdown() {
  return isSHutdown;
 }
 public void setSHutdown(boolean isSHutdown) {
  this.isSHutdown = isSHutdown;
 }
 public boolean isIdle() {
  return isIdle;
 }
 public void setIdle(boolean isIdle) {
  this.isIdle = isIdle;
 } 
 @Override
 public void run() {
  //只要没有关闭，则一直不结束该线程
  while(!isSHutdown){
   isIdle=false;
   if (target!=null) {
    //运行任务
    target.run();
   }
   //任务结束，到闲置状态
   isIdle=true;
   try {
    //该线程任务结束后，不关闭线程，而是放入线程池空闲对了
    pool.repool(this);
    synchronized (this) {
     wait();
    }
    
   } catch (Exception e) {
    // TODO: handle exception
   }
   isIdle=false;
  }
 }
 //关闭线程
 public  synchronized void shutdown(){
  isSHutdown=true;
  notifyAll();
 } 
}

 

package com.mzsx.concurrent.threadpool;
public class MyThread implements Runnable {
 protected String name;
 
 public MyThread() {
 }
 public MyThread(String name) {
  super();
  this.name = name;
 }

 @Override
 public void run() {
  try {
   System.out.println(this.name);
   Thread.sleep(1);
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
 }
}

package com.mzsx.concurrent.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //不使用线程池
  /*for (int i = 0; i < 1000; i++) {
   new Thread(new MyThread("MyThread-"+i)).start();
  }*/
  //使用线程池
  /*for (int i = 0; i < 1000; i++) {
   ThreadPool.getInstance().start(new MyThread("MyThread-"+i));
  }*/
  //JDK自带的线程池
  ExecutorService executorService=Executors.newCachedThreadPool();
  for (int i = 0; i < 1000; i++) {
   executorService.execute(new MyThread("MyThread-"+i));
  }
 }
}