线程池单例类

package com.study.googleplay.manager;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
import java.util.concurrent.TimeUnit;

public class ThreadManager {

	/**
	 * 线程池
	 * 
	 * @author TCL
	 * @date 2016-6-13
	 */
	private static ThreadPool threadPoolpool;

	public static ThreadPool getInstance() {
		if (threadPoolpool == null) {
			synchronized (ThreadManager.class) {
				if (threadPoolpool == null) {
					int threadCount = Runtime.getRuntime()
							.availableProcessors() * 2 + 1;// 线程个数
					threadPoolpool = new ThreadPool(threadCount, threadCount,
							1L);
				}
			}
		}
		return threadPoolpool;
	}

	public static class ThreadPool {
		private int corePoolSize;// 核心线程数
		private int maximumPoolSize;// 最大线程数
		private long keepAliveTime;// 休息时间
		private ThreadPoolExecutor executor;

		private ThreadPool(int corePoolSize, int maximumPoolSize,
				long keepAliveTime) {
			this.corePoolSize = corePoolSize;
			this.maximumPoolSize = maximumPoolSize;
			this.keepAliveTime = keepAliveTime;

		}

		public void execute(Runnable r) {
			// 参数1：核心线程数，参数2：最大线程数，参数3：休息时间，参数4：时间单位，
			// 参数5：线程队列参数6：生产线程的工厂，参数7：线程异常策略
			if (executor == null) {
				executor = new ThreadPoolExecutor(corePoolSize,
						maximumPoolSize, keepAliveTime, TimeUnit.SECONDS,
						new LinkedBlockingDeque<Runnable>(),
						Executors.defaultThreadFactory(), new AbortPolicy());
			}
			executor.execute(r);// 执行一个Runnable对象，具体执行时机由线程池说了算
		}

		// 取消任务
		public void cancel(Runnable r) {
			if (r != null) {
				// 如果任务还没开始，正在等待，可以通过 此方法移除，
				// 如果任务已经开始，需要在run方法中进行中断
				executor.getQueue().remove(r);// 从线程池中移除对象
			}
		}
	}
}