新建一个线程并启动，开销会很大，因为运行线程需要的资源比调用对象方法需要的资源多得多。在很多情况下，线程被用于执行一类任务，而这类任务数量很多，发生的时间分布不均，如果为每个新任务都启用一个新线程来执行，则开销会太大，可以采用一种性能优化技术，就是使用线程池。
将若干执行任务的线程放在池中，当有任务要执行时，从池中取出一个空闲线程来处理任务，处理完任务后，再讲线程对象放入池中。线程池实际上就是一个对象池，只是池中的对象都是线程。
本文实例将实现一个线程池，可以给线程池分配任务，线程池中的线程自动获取任务并执行。
关键技术：1.线程组ThreadGroup可以管理多个线程，所以让线程池继承ThreadGroup。
2.无条件关闭线程池时，通过ThreadGroup的interrupt方法中断池中的所有线程。
3.有条件关闭线程池时，通过ThreadGroup获得池中所有活动线程的引用，依次调用Thread的join方法等待活动线程执行完毕。当所有线程都运行结束时，线程池才 能被关闭。
4.将任务放在LinkedList中，由于LinkedList不支持同步，所以在添加任务和获取任务的方法声明中必须使用Synchronized关键字。
实例
package book.thread.pool;
/**
*定义任务的接口类
*/
public interface Task {
public void perform() throws Exception;
}
package book.thread.pool;
public class MyTask implements Task{
private int taskID = 0;//任务ID
public MyTask(int id){
this.taskID = id;
}
@Override
public void perform() throws Exception {
System.out.println("MyTask " + taskID + ":start");
Thread.sleep(1000);
System.out.println("MyTask " + taskID + ":end");
}
}
package book.thread.pool;
import java.util.LinkedList;
public class MyThreadPool extends ThreadGroup{
private boolean isAlive;//标志线程池是否开启
private LinkedList taskQueue;//线程池中的任务队列
private int threadID;//线程池中的线程ID
private static int threadPoolID;//线程池ID
//创建新的线程池，numThreads是池中的线程数
public MyThreadPool(int numThreads){
super("ThreadPool-"+(threadPoolID++));
//设置该线程池的Daemon属性为true，表示当该线程池中的所有线程都被销毁时，该线程池会自动被销毁
super.setDaemon(true);
this.isAlive = true;
this.taskQueue = new LinkedList();//新建一个任务队列
//启动numThreads个工作线程
for(int i = 0;i < numThreads; i++){
new PooledThread().start();
}
}
//添加新任务
public synchronized void performTask(Task task){
if(!this.isAlive){
throw new IllegalStateException();//线程池被关闭，则抛出异常
}
if(task != null){
this.taskQueue.add(task);//将任务放到任务队列的尾部
notify();//通知工作线程取任务
}
}
//获取任务
protected synchronized Task getTask() throws InterruptedException{
//如果任务列表为空，而且线程池没有被关闭，则继续等待任务
while(this.taskQueue.size() == 0){
if(!this.isAlive){
return null;
}
wait();
}
//取任务列表的第一个任务
return (Task)this.taskQueue.removeFirst();
}
//关闭线程池，所有线程停止，不再执行任务
public synchronized void close(){
if(isAlive){
this.isAlive = false;
this.taskQueue.clear();//清除任务
this.interrupt();//中止线程池中的所有线程
}
}
//关闭线程池，并等待线程池中的所有任务运行完成，但不能接收新任务
public void join(){
//通知其他等待线程“该线程池已关闭”的消息
synchronized(this){
isAlive = false;
notifyAll();
}
//等待所有线程完成，首先建立一个新的线程组，activeCount方法获取线程池中活动线程的估计数
Thread[] threads = new Thread[this.activeCount()];
//将线程池中的活动线程拷贝到新创建的线程组threads中
int count = this.enumerate(threads);
for(int i = 0;i < count; i++){
try {
threads[i].join();//等待线程运行结束
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//内部类,用于执行任务的工作线程
private class PooledThread extends Thread{
public PooledThread(){
//第一个参数为该线程所在的线程组对象，即当前线程池对象
//第二个参数为线程名字
super(MyThreadPool.this,"PooledThread-" +(threadID++));
}
public void run(){
//如果该线程没有被中止
while(!isInterrupted()){
//获取任务
Task task = null;
try {
task = getTask();
} catch (InterruptedException e) {
e.printStackTrace();
}
//只要线程池的任务列表不为空，getTask方法就总能得到一个任务
//若getTask()返回null,则表示线程池中已经没有任务，而且线程池已经被关闭
if(task == null){
return;
}
//运行任务，捕捉异常
try {
task.perform();
} catch (Exception e) {
uncaughtException(this,e);
}
}
}
}
}
package book.thread.pool;
public class PoolTest {
public static void main(String[] args) {
int numThreads = 3;//线程池中的线程数
MyThreadPool threadPool = new MyThreadPool(numThreads);//生成线程池
int numTasks = 10;//任务数
//运行任务
for(int i = 0;i<numTasks;i++){
threadPool.performTask(new MyTask(i));
}
//关闭线程池并等待所有任务完成
threadPool.join();
}
}
输出结果：
MyTask 0:start
MyTask 1:start
MyTask 2:start
MyTask 0:end
MyTask 3:start
MyTask 1:end
MyTask 4:start
MyTask 2:end
MyTask 5:start
MyTask 3:end
MyTask 6:start
MyTask 4:end
MyTask 7:start
MyTask 5:end
MyTask 8:start
MyTask 6:end
MyTask 9:start
MyTask 7:end
MyTask 8:end
MyTask 9:end
结果分析：MyThreadPool类是线程池的主体类，用于管理一组工作线程。
1.继承ThreadGroup，可以使用ThreadGroup提供的方法管理线程池中的线程。
2.performTask公有同步方法往线程池的任务队列中添加一个任务。如果线程池已被关闭，即isAlive属性为false，则不允许添加任务；添加任务后，调用notify方 法，通知池中的工作线程取任务。
3.getTask受保护同步方法从线程池的任务队列中获取一个任务。之所以声明为受保护的，是为了限制其他类的对象非法获取任务。如果任务队列中没有任务，则当 前线程进入等待状态，如果线程池已被关闭，则直接返回null。
4.close方法强制关闭线程池。通过ThreadGroup的interrupt方法中断线程池中所有运行的线程，清空任务队列，并且isAlive属性设置为false，表示不接收新任务
5.join方法有条件的关闭线程池。isAlive属性置为false，表示线程池不再接收新任务，通过ThreadGroup获得正在运行的线程，通过Thread的join方法等待他们执 行完任务后，再关闭线程池。
PooledThread类是MyThreadPool的内部类，定义了工作线程，处于MyThreadPool线程池中。在run放在中不断的从线程池的任务队列中取任务，取到任务后，调用任务的perform方法执行任务。
来源：oschina
链接：https://my.oschina.net/u/2731508/blog/714150