package com.gxx.record.core;
 
import java.util.LinkedList;
import java.util.List;
 
import org.apache.log4j.Logger;
 
/** 
 * 线程池
 * @author Gxx
 */
public class ThreadPool {
	/**
	 * 日志记录器
	 */
	private Logger logger = Logger.getLogger(ThreadPool.class);
	/**
	 * 线程池
	 */
	private static ThreadPool pool;
	/**
	 * 总线程数
	 */
	private int totalThread = 5;
	/**
	 * 工作线程
	 */
	private WorkThread[] workThreads;
	/**
	 * 任务队列
	 */
	private List<Runnable> taskQueue = new LinkedList<Runnable>();
	/**
	 * 构造方法
	 */
	private ThreadPool() {
		this(5);
	}
	/**
	 * 构造方法
	 * @param totalThread
	 */
	private ThreadPool(int totalThread) {
		logger.info("初始化" + totalThread + "个工作线程开始!");
		this.totalThread = totalThread;
		workThreads = new WorkThread[totalThread];
		for(int i=0;i<totalThread;i++) {
			workThreads[i] = new WorkThread("工作线程" + (i+1));
			workThreads[i].start();
		}
		logger.info("初始化" + totalThread + "个工作线程结束!");
	}
	/**
	 * 单例返回线程池
	 * @return
	 */
	public static synchronized ThreadPool getThreadPool() {
		if(pool == null) {
			pool = new ThreadPool();
		}
		return pool;
	}
	/**
	 * 执行线程任务->把线程任务放入队列
	 * @param task
	 */
	public void execute(Runnable task) {
		synchronized(taskQueue) {
			taskQueue.add(task);
			taskQueue.notify();
		}
	}
	/**
	 * 返回总线程数
	 * @return
	 */
	public int getTotalThread() {
		return totalThread;
	}
	/**
	 * 销毁线程池
	 */
	public void destroy() {
		for(int i=0;i<workThreads.length;i++) {
			if(null != workThreads[i]) {
				workThreads[i].running = false;
				workThreads[i] = null;
			}
		}
	}
 
	/** 
	 * 工作线程
	 * @author Gxx
	 */
	public class WorkThread extends Thread {
		/**
		 * 是否运行标志
		 */
		boolean running = true;
 
		WorkThread(String name) {
			this.setName(name);
		}
 
		@Override
		public void run() {
			Runnable task = null;
			/**
			 * 工作线程一直工作，循环判断是否有待执行任务
			 */
			while(running) {
				synchronized(taskQueue) {
					/**
					 * 没有任务，则睡眠一段时间，直到获取到任务
					 */
					while(running && taskQueue.isEmpty()) {
						logger.info(this.getName() + "睡眠2秒，队列是空的！");
						try {
							/**
							 * 设置2秒便于观察，应该设置时间短一点，比如20毫秒
							 */
							taskQueue.wait(2000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						logger.info(this.getName() + "唤醒");
					}
					/**
					 * 获取任务
					 */
					if(!taskQueue.isEmpty()) {
						logger.info("队列长度是" + taskQueue.size());
						task = taskQueue.remove(0);
					}
				}
				/**
				 * 执行任务
				 */
				if(task != null) {
					logger.info(this.getName() + "开始执行任务");
					task.run();
				}
				task = null;
			}
		}
	}
}

package com.gxx.record.thread;
 
import org.apache.log4j.Logger;
 
/**
 * <dl>
 *    <dt><b>Title:</b></dt>
 *    <dd>
 *    	none
 *    </dd>
 *    <dt><b>Description:测试线程</b></dt>
 *    <dd>
 *    	<p>none
 *    </dd>
 * </dl>
 *
 * @author Administrator
 * @version 1.0, 2017年5月16日
 * @since record
 */
public class TaskThread extends Thread {
	/**
	 * 日志处理器
	 */
	private final Logger logger = Logger.getLogger(TaskThread.class);
 
	/**
	 * 构造函数
	 * @param name
	 */
	public TaskThread(String name) {
		this.setName(name);
	}
 
	@Override
	public void run() {
		logger.info("线程[" + this.getName() + "]开始====");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			logger.error("异常发生", e);
		}
		logger.info("线程[" + this.getName() + "]结束====");
	}
}

/**
	 * 测试ThreadPool
	 * @param request
	 * @return
	 */
	@RequestMapping(value = "/testThreadPool",produces="application/json")
	public @ResponseBody String testThreadPool() {
		logger.info("测试ThreadPool，开始===");
		for(int i=0;i<10;i++) {
			ThreadPool.getThreadPool().execute(new TaskThread("T" + (i+1)));
		}
		logger.info("测试ThreadPool，结束===");
		return "testThreadPoolOK~";
	}
 
	/**
	 * 测试ThreadPoolDestroy
	 * @param request
	 * @return
	 */
	@RequestMapping(value = "/testThreadPoolDestroy",produces="application/json")
	public @ResponseBody String testThreadPoolDestroy() {
		logger.info("测试ThreadPoolDestroy，开始===");
		ThreadPool.getThreadPool().destroy();
		logger.info("测试ThreadPoolDestroy，结束===");
		return "testThreadPoolDestroyOK~";
	}