Java单线程池

package com.hebei.read.core.plugins.thread;

import java.util.LinkedList;

/**
 * 自定义线程池
 * 
 * @author Admin
 * 
 */
public class SinglePool extends ThreadGroup {

	private static boolean isClose = false;// 线程池是否关闭
	private static LinkedList workQueue; // 工作队列
	private static SinglePool pool = null;
	private static WorkThread work = null;

	public static SinglePool getInstance() {
		if (pool == null) {
			pool = new SinglePool();
		}
		return pool;
	}

	/**
	 * 初始化线程池
	 * 
	 * @param poolSize
	 */
	private SinglePool() {
		super("zaichi thread group");
		setDaemon(true);
		workQueue = new LinkedList();
		work = new WorkThread();
		work.start();
	}

	public synchronized void execute(Runnable task) {
		if (isClose) {
			throw new IllegalStateException();
		}
		if (task != null) {
			workQueue.add(task);
			notify();
		}
	}

	// 从工作队列中取出一个任务，工作线程会调用该方法
	private synchronized Runnable getTask() throws InterruptedException {
		while (workQueue.size() == 0) {
			if (isClose) {
				return null;
			}
			wait(); // 如果工作线程中没有任务，那么就等待着
		}
		return (Runnable) workQueue.removeFirst();// 返回队列中的第一个元素，并从队列中删除
	}

	/**
	 * 线程是否在运行
	 * 
	 * @return
	 */
	public synchronized boolean isRunning(Thread t) {
		return workQueue.size() > 0 || work.isRunning();
	}

	/**
	 * 线程是否在运行
	 * 
	 * @return
	 */
	public synchronized boolean isRunning() {
		return workQueue.size() > 0 || work.isRunning();
	}

	// 等待工作线程把任务执行完成
	private void waitFinish() {
		synchronized (this) {
			isClose = true;
			notifyAll(); // 唤醒所有还在getTask()方法中等待任务的工作线程
		}
		Thread[] threads = new Thread[activeCount()]; // activeCount()返回该线程组中活动线程的估计值
		int count = enumerate(threads); // enumerate方法继承自ThreadGroup，根据活动的线程的估计值获得该线程组中当前所有活动的工作线程
		for (int i = 0; i < count; i++) { // 等待所有工作线程结束
			try {
				threads[i].join(); // 等待工作线程结束
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	// 关闭线程池
	public synchronized void shutdown() {
		if (!isClose) {
			waitFinish(); // 等待工作线程执行完毕
			isClose = true;
			workQueue.clear(); // 清空工作队列
			interrupt(); // 中断线程池所有的工作线程
		}
	}

	/**
	 * 多线程的工作线程
	 * 
	 * @author Admin
	 * 
	 */
	private class WorkThread extends Thread {

		private boolean running = false;
		private int m = 0;

		public WorkThread() {
			super(SinglePool.this, "zaichi single thread");
		}

		public boolean isRunning(int n) {
			if (m == n) {
				return running;
			} else {
				return false;
			}
		}

		public boolean isRunning() {
			return running;
		}

		public void run() {
			while (!isInterrupted()) { // 继承自Thread，判断线程是否被中断
				Runnable task = null;
				try {
					task = getTask(); // 取出任务
					m = task.hashCode();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
				if (task == null) {
					return;
				}
				running = true;
				task.run(); // 运行任务
				running = false;
			}
		}
	}
}