线程学习笔记(十二)-线程池

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程，每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。本实例介绍如何运用线程池实现任务的执行。

技术要点

运用线程池实现任务的执行的技术要点如下：

如果某个线程在托管代码中空闲，则线程池将插入另一个辅助线程(线程池)来使所有处理器保持繁忙；如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则 线程池将在一段时间后创建另一个辅助线程(线程池)，但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但它们要等到其他线程完成后后才启动。

任务放在LinkedList中，由于LinkedList不支持同步，所以在添加任务和获取任务的方法声明中必须使用synchronized关键字

关闭线程池时，通过ThreadGroup线程组获得池中所有活动线程的引用，依次调用Thread类的join()方法等待活动线程执行完毕。当所有线程运行结束是，线程池才算被关闭。

package core;

import java.util.LinkedList;

class ThreadPool extends ThreadGroup {
	private static int threadPool_ID = 1; // 线程池的编号
	private LinkedList<Runnable> taskQueue; // 工作任务队列
	private boolean isClosed = false;// 线程池是否关闭

	private class TaskThread extends Thread {
		private int id;

		public TaskThread(int id) {
			super(ThreadPool.this, id + "");// 将线程加入到当前线程组中
			this.id = id;
		}

		public void run() {
			while (!isInterrupted()) {// 判断线程是否被中断
				Runnable task = null;
				task = getTask(id);// 取出任务
				// 如果getTask()返回null或者线程执行getTask()被中断，则结束此线程
				if (task == null)
					return;
				try {
					task.run(); // 运行任务
				} catch (Throwable t) {
					t.printStackTrace();
				}

			}
		}
	}

	public synchronized Runnable getTask(int id) {
		try {
			while (taskQueue.size() == 0) {// 循环使线程等待任务
				if (isClosed)
					return null;
				System.out.println("工作线程" + id + "等待任务");
				wait();// 如果任务队列中没有任务，就等待任务
			}
		} catch (InterruptedException e) {
			System.out.println("等待任务出现错误： " + e.getMessage());
		}
		System.out.println("工作线程" + id + "开始执行任务。。。。");
		return (Runnable) taskQueue.removeFirst();// 返回第一个任务并从队列中删除
	}

	public ThreadPool(int poolsize) {
		super(threadPool_ID + " ");
		setDaemon(true);
		taskQueue = new LinkedList<Runnable>();// 创建工作任务队列
		for (int i = 0; i < poolsize; i++) {// 循环创建任务线程
			new TaskThread(i).start();//根据线程池数据创建任务线程并启动线程
		}
	}
	public   synchronized void exexcuteTask(Runnable task){//添加新任务并执行任务
		if(isClosed){
			throw new IllegalStateException();//抛出不合理状态异常
		}
		if(task !=null){
			taskQueue.add(task);//向任务队列中加入一个任务
			notify();//唤醒线程池中等待任务的工作任务线程
		}
	}
	public void waitTaskFinish(){
		synchronized(this){
			isClosed=true;
			notifyAll();//唤醒所有等待任务的工作任务线程
		}
		Thread[] threads=new Thread[activeCount()];//创建线程组中活动的线程组
		int count=enumerate(threads);//获得线程组中当前所有活动的工作线程
		for (int i = 0; i < count; i++) {
			try {
				threads[i].join();
			} catch (InterruptedException e) {
				System.out.println("任务执行出错： " + e.getMessage());

			}
		}
	}
	public synchronized void closeThreadPool(){//关闭线程池
		if(!isClosed){    //判断标识
			waitTaskFinish();  //等待任务线程执行完毕
			isClosed=true;   //标识为真
			taskQueue.clear();//任务队列清空
			interrupt();//唤醒线程池中所有的工作线程
		}
	}
}

public class TextThreadPool {
	private static Runnable createTask(final int taskID) {// 创建任务方法
		return new Runnable() {
			@Override
			public void run() {
				System.out.println("任务开始，编号为" + taskID);
				System.out.println("start task");
				System.out.println("任务结束，编号为" + taskID);
			}
		};
	}

	public static void main(String[] args) {
		ThreadPool threadPool=new ThreadPool(3); //初始化创建3个任务线程的线程池,等待执行任务
		try {//休眠600毫秒，让线程池中的任务线程全部运行
			Thread.sleep(600);
		} catch (InterruptedException e) {
			System.out.println("线程休眠出错： "+e.getMessage());
		}
		for (int i = 0; i < 5; i++) { //循环创建并执行任务
			threadPool.exexcuteTask(createTask(i));
		}
		threadPool.waitTaskFinish();//等待所有任务执行完毕
		threadPool.closeThreadPool();//关闭线程池
	}
}

源程序解读

(1)TextThreadPool类的createTask()方法根据任务编号执行指定的任务。在类的main()主方法中实例化三个ThreadPool对象作为线程池，Thread类的sleep()方法使线程休眠0.6秒，运用循环执行创建的工作任务，如果没有创建工作任务，则线程池的三个ThreadPool则会一直等待，调用waitTaskFinish()方法等待所有的任务执行完毕再关闭线程池。

(2)内部类ThreadPool继承线程组类ThreadGroup实现线程池的功能。其私有内部类TaskThread继承Thread线程类，扩展run()方法。在run()方法中根据标识为真进行循环。根据Thread类的getTask()方法获得Runnable任务对象，调用任务对象的run()方法执行任务。

(3)ThreadPool类的构造方法传入线程池中工作线程的数量，设置该类为守护线程类，并创建双向链表。运用循环创建任务线程并启动线程。executeTask()方法是往双向链表中添加任务对象并唤醒等待任务的工作任务线程。getTask()方法根据编号获得指定的任务，并移除双向链表中的双向链表中的第一个任务线程。

(4)waitTaskFinish()方法是等待任务线程执行所有的任务。在其同步块中唤醒等待任务的工作任务线程并设置标识为真。根据活动的线程数创建现场数组，根据活动的线程获得线程组中当前所有活动的工作线程，再运用循环通过join()方法等待所有工作线程结束。closeThreadPool()方法判断标识，如果标识为真，则调用waitTaskFinish()方法将等待的任务线程的所有的任务执行完毕。若设置标识为假，清空双向链表中的任务，唤醒线程池中的所有工作线程。

(5) 对于线程池的三个ThreadPool对象运用了wait和notify的方法。在getTask方法中使用wait方法来等待工作任务，等待list元素；exexcuteTask()方法中把工作任务放入list后，便调用notify方法通知线程池的三个ThreadPool对象取工作任务。