JAVA创建自己的线程池

package proxy;

import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

//测试main入口

public class CocurrentThread {

public static void main(String[] args){

  //创建一个线程池，可以运行5条线程
  PoolThread pt = new PoolThread(5);

  //开启线程池工作开关
  pt.start();

  //往线程池中加入10个任务
  for(int i = 0;i < 10;i++){
   pt.execute(new ConcreteTask());
  }

  //关闭线程池开关
  pt.shutdown();
 
}


}

/**

*要交给线程池处理的具体任务，用户可以自定义，不一定要实现Runnable接口，这里实现

*Runnable只是利用Runnable接口生成一种规范。
**/
class ConcreteTask implements Runnable{
private static int i;

//具体实现的任务在这里编写
public void run() {
  System.out.println(Thread.currentThread().toString() + i++);
}

}



/**

*线程池核心类
**/
class PoolThread{

//实现线程池对象时最大的可用线程数
private int maxThreads;


//线程池工作的启动开关
private boolean on = false;


//这里定义了一个任务队列容器，用途很明显，就是用来放置要处理的任务，先进来的先交给线程池处理
private Queue<Runnable> tasks = new ConcurrentLinkedQueue<Runnable>();//任务队列


//定义了一个放置Thread对象的容器，用来放置所有的线程
private List<Thread> poolThreads ;


//构造器，初始化时根据传入的参数来分配几条线程处理任务
public PoolThread(int maxThreads){
  this.maxThreads = maxThreads;
  poolThreads = new ArrayList<Thread>();
  for(int i = 0;i < this.maxThreads;i++){
   poolThreads.add(new Thread(new SingleThread()));
  }
}
/**

*启动线程池，其实就是启动里面的每一条线程

*/
public void start(){
  this.on = true;
  for(int i = 0 ;i < poolThreads.size();i++){

//启动每个线程
   poolThreads.get(i).start();
   System.out.println("the number " + i + " thread of " + poolThreads.size());
  }
}


/**

*关闭线程池的工作

*/
public void shutdown(){
  this.on = false;
}

/**
  *
  * @param task 被执行的新任务，实现Runnable接口
  */
public void execute(Runnable task){
  synchronized(tasks){
   tasks.add(task);//将任务添加到线程池中执行
   tasks.notifyAll();  //通知所有的锁定tasks线程，让其执行新加进来的任务
  }
}


/**

*定义线程池中的线程类,该线程必需是永远不终止的。

*/
class SingleThread implements Runnable{

  public void run() {
   while(on){
    synchronized(tasks){
     Runnable task = tasks.poll();   //取出任务队列中的任务执行
     if(task != null)
      task.run();
     if(tasks.size() == 0){    //如果队列中没有等待的任务，则停止线程，直到有任务加进队列时唤醒该线程
      try {
       tasks.wait();
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }
    }
   }
  
  }
 
}
}