线程池单例类

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);// 从线程池中移除对象
}
}
}
}