线程池学习

　　新建一个线程并启动，开销会很大，因为运行线程需要的资源比调用对象方法需要的资源多得多。在很多情况下，线程被用于执行一类任务，而这类任务数量很多，发生的时间分布不均，如果为每个新任务都启用一个新线程来执行，则开销会太大，可以采用一种性能优化技术，就是使用线程池。

　　将若干执行任务的线程放在池中，当有任务要执行时，从池中取出一个空闲线程来处理任务，处理完任务后，再讲线程对象放入池中。线程池实际上就是一个对象池，只是池中的对象都是线程。

　　本文实例将实现一个线程池，可以给线程池分配任务，线程池中的线程自动获取任务并执行。

　　关键技术：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();//通知工作线程取任务

　　　　}

　　}

　　//获取任务http://item.taobao.com/item.htm?id=41222768202

　　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();

　　　　}http://item.taobao.com/item.htm?id=41222768202

　　//等待所有线程完成，首先建立一个新的线程组，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;

　　　　}http://item.taobao.com/item.htm?id=41222768202

　　　　//运行任务，捕捉异常

　　　　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();

　　}

}

输出结果：http://item.taobao.com/item.htm?id=41222768202

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方法执行任务。