线程池的优点：
（1）复用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
（2）能够有效的控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
（3）能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。
线程池的构造方法:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
// 参1:核心线程数，除非allowCoreThreadTimeOut被设置为true，否则它闲着也不会死
// 参2:最大线程数,活动线程数量超过它，后续任务就会排队 ;
// 参3:超时时长，作用于非核心线程（allowCoreThreadTimeOut被设置为true时也会同时作用于核心线程），闲置超时便被回收 ;
// 参4:枚举类型，设置keepAliveTime的单位;
// 参5:缓冲任务队列，线程池的execute方法会将Runnable对象存储起来 ;
// 参6:线程工厂接口，只有一个new Thread(Runnable r)方法，可为线程池创建新线程 ;线程池工具类1：
package com.example.administrator.survey.utils;
import java.util.Comparator;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 线程任务类,用来管理程序中出现的所有线程 主要分为三个线程池，dbThreadPool,netThreadPool,otherThreadPool
*/
public class ThreadTask {
/**
* 线程任务的实例
*/
private static ThreadTask instance;
/**
* 网络线程最大数量
*/
private final int netThreadCount = 5;
/**
* 数据库线程最大数量
*/
private final int dbThreadCount = 3;
/**
* 其他类型的耗时线程数量
*/
private final int otherThreadCount = 10;
/**
* 数据库线程池
*/
private ThreadPoolExecutor dbThreadPool;
/**
* 网络线程池
*/
private ThreadPoolExecutor netThreadPool;
/**
* 其他耗时操作线程池
*/
private ThreadPoolExecutor otherThreadPool;
/**
* 数据库线程队列
*/
private PriorityBlockingQueue dbThreadQueue;
/**
* 网络线程队列
*/
private PriorityBlockingQueue netThreadQueue;
/**
* 其他线程队列
*/
private PriorityBlockingQueue otherThreadQueue;
/**
* 任务比较
*/
private Comparator<PrioriTask> taskCompare;
private ThreadTask() {
final long keepAliveTime = 60L;
taskCompare = new TaskCompare();
dbThreadQueue = new PriorityBlockingQueue<PrioriTask>(dbThreadCount, taskCompare);
netThreadQueue = new PriorityBlockingQueue<PrioriTask>(netThreadCount, taskCompare);
otherThreadQueue = new PriorityBlockingQueue<PrioriTask>(dbThreadCount, taskCompare);
dbThreadPool = new ThreadPoolExecutor(dbThreadCount, dbThreadCount, 0L, TimeUnit.MILLISECONDS, dbThreadQueue);
netThreadPool = new ThreadPoolExecutor(netThreadCount, netThreadCount, 0L, TimeUnit.MILLISECONDS, netThreadQueue);
otherThreadPool = new ThreadPoolExecutor(otherThreadCount, Integer.MAX_VALUE, keepAliveTime, TimeUnit.SECONDS, otherThreadQueue);
}
/**
* 获取线程管理实例
*
* @return 线程管理实例
*/
public static ThreadTask getInstance() {
if (instance == null) {
instance = new ThreadTask();
}
return instance;
}
/**
* 获取网络线程池
*
* @return
*/
public ThreadPoolExecutor getNetThreadPool() {
return netThreadPool;
}
/**
* 执行数据库线程
*
* @param task 需要执行的任务
* @param priority 优先级 {@link ThreadPeriod}
*/
public void executorDBThread(Runnable task, int priority) {
if (!dbThreadPool.isShutdown()) {
dbThreadPool.execute(new PrioriTask(priority, task));
}
}
/**
* 执行网络线程
*
* @param task 需要执行的任务
* @param priority {@link ThreadPeriod} 优先级
*/
public void executorNetThread(Runnable task, int priority) {
if (!netThreadPool.isShutdown()) {
netThreadPool.execute(new PrioriTask(priority, task));
}
}
/**
* 执行除数据库之外的其他耗时任务
*
* @param task 需要执行的任务
* @param priority {@link ThreadPeriod} 优先级
*/
public void executorOtherThread(Runnable task, int priority) {
if (!otherThreadPool.isShutdown()) {
otherThreadPool.execute(new PrioriTask(priority, task));
}
}
/**
* 结束掉所有线程,并且回收（正在进行的有可能结束不掉）
*/
public void shutDownAll() {
netThreadPool.shutdownNow();
dbThreadPool.shutdownNow();
otherThreadPool.shutdownNow();
instance = null;
}
/**
* 优先级任务
*
* @author RES-KUNZHU
*/
public class PrioriTask implements Runnable {
private int priori;
private Runnable task;
/**
* Cnstructor Method。
*
* @param priority 优先级
* @param runnable 线程
*/
public PrioriTask(int priority, Runnable runnable) {
priori = priority;
task = runnable;
}
public int getPriori() {
return priori;
}
public void setPriori(int priori) {
this.priori = priori;
}
public Runnable getTask() {
return task;
}
public void setTask(Runnable task) {
this.task = task;
}
@Override
public void run() {
if (task != null) {
task.run();
}
}
}
/**
* 任务比较器
*
* @author RES-KUNZHU
*/
public class TaskCompare implements Comparator<PrioriTask> {
@Override
public int compare(PrioriTask lhs, PrioriTask rhs) {
return rhs.getPriori() - lhs.getPriori();
}
}
/**
* 线程优先级
*
* @author RES-KUNZHU
*/
public static class ThreadPeriod {
/**
* 线程优先级 低
*/
public static final int PERIOD_LOW = 1;
/**
* 线程优先级 中
*/
public static final int PERIOD_MIDDLE = 5;
/**
* 线程优先级 高
*/
public static final int PERIOD_HIGHT = 10;
}
}
线程池工具类2：
package com.xiaoyehai.threadpool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
import java.util.concurrent.TimeUnit;
/**
* 线程管理器
*
* @author Kevin
* @date 2015-11-4
*/
public class ThreadManager {
private static ThreadPool mThreadPool;
public static ThreadPool getThreadPool() {
if (mThreadPool == null) {
synchronized (ThreadManager.class) {
if (mThreadPool == null) {
int cpuCount = Runtime.getRuntime().availableProcessors();// 获取cpu数量
// System.out.println("cup个数:" + cpuCount);
// int threadCount = cpuCount * 2 + 1;//线程个数
int threadCount = 10;
mThreadPool = new ThreadPool(threadCount, threadCount, 1L);
}
}
}
return mThreadPool;
}
// 线程池
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;
}
// 线程池几个参数的理解:
// 比如去火车站买票, 有10个售票窗口, 但只有5个窗口对外开放. 那么对外开放的5个窗口称为核心线程数,
// 而最大线程数是10个窗口.
// 如果5个窗口都被占用, 那么后来的人就必须在后面排队, 但后来售票厅人越来越多, 已经人满为患, 就类似于线程队列已满.
// 这时候火车站站长下令, 把剩下的5个窗口也打开, 也就是目前已经有10个窗口同时运行. 后来又来了一批人,
// 10个窗口也处理不过来了, 而且售票厅人已经满了, 这时候站长就下令封锁入口,不允许其他人再进来, 这就是线程异常处理策略.
// 而线程存活时间指的是, 允许售票员休息的最长时间, 以此限制售票员偷懒的行为.
public void execute(Runnable r) {
if (executor == null) {
executor = new ThreadPoolExecutor(corePoolSize,
maximumPoolSize, keepAliveTime, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(),
Executors.defaultThreadFactory(), new AbortPolicy());
// 参1:核心线程数，除非allowCoreThreadTimeOut被设置为true，否则它闲着也不会死
// 参2:最大线程数,活动线程数量超过它，后续任务就会排队 ;
// 参3:超时时长，作用于非核心线程（allowCoreThreadTimeOut被设置为true时也会同时作用于核心线程），闲置超时便被回收 ;
// 参4:枚举类型，设置keepAliveTime的单位;
// 参5:缓冲任务队列，线程池的execute方法会将Runnable对象存储起来 ;
// 参6:线程工厂接口，只有一个new Thread(Runnable r)方法，可为线程池创建新线程 ;
// 参7:线程异常处理策略
}
// 线程池执行一个Runnable对象, 具体运行时机线程池说了算
executor.execute(r);
}
// 取消任务
public void cancel(Runnable r) {
if (executor != null) {
// 从线程队列中移除对象
executor.getQueue().remove(r);
}
}
}
}
线程池工具类3：
package com.uflycn.ugrid.utils;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
* Created by Ryan on 2017/1/16.
*/
public class ThreadPoolUtils {
private ThreadPoolUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
public enum Type {
FixedThread,
CachedThread,
SingleThread,
}
private ExecutorService exec;
private ScheduledExecutorService scheduleExec;
/**
* ThreadPoolUtils构造函数
*
* @param type 线程池类型
* @param corePoolSize 只对Fixed和Scheduled线程池起效
*/
public ThreadPoolUtils(Type type, int corePoolSize) {
// 构造有定时功能的线程池
// ThreadPoolExecutor(corePoolSize, Integer.MAX_VALUE, 10L, TimeUnit.MILLISECONDS, new BlockingQueue<Runnable>)
scheduleExec = Executors.newScheduledThreadPool(corePoolSize);
switch (type) {
case FixedThread:
// 构造一个固定线程数目的线程池
// ThreadPoolExecutor(corePoolSize, corePoolSize, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
exec = Executors.newFixedThreadPool(corePoolSize);
break;
case SingleThread:
// 构造一个只支持一个线程的线程池,相当于newFixedThreadPool(1)
// ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())
exec = Executors.newSingleThreadExecutor();
break;
case CachedThread:
// 构造一个缓冲功能的线程池
// ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
exec = Executors.newCachedThreadPool();
break;
default:
exec = scheduleExec;
break;
}
}
/**
* 在未来某个时间执行给定的命令
* <p>该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。</p>
*
* @param command 命令
*/
public void execute(Runnable command) {
exec.execute(command);
}
/**
* 在未来某个时间执行给定的命令链表
* <p>该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。</p>
*
* @param commands 命令链表
*/
public void execute(List<Runnable> commands) {
for (Runnable command : commands) {
exec.execute(command);
}
}
/**
* 待以前提交的任务执行完毕后关闭线程池
* <p>启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
* 如果已经关闭，则调用没有作用。</p>
*/
public void shutDown() {
exec.shutdown();
}
/**
* 试图停止所有正在执行的活动任务
* <p>试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。</p>
* <p>无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。</p>
*
* @return 等待执行的任务的列表
*/
public List<Runnable> shutDownNow() {
return exec.shutdownNow();
}
/**
* 判断线程池是否已关闭
*
* @return {@code true}: 是<br>{@code false}: 否
*/
public boolean isShutDown() {
return exec.isShutdown();
}
/**
* 关闭线程池后判断所有任务是否都已完成
* <p>注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。</p>
*
* @return {@code true}: 是<br>{@code false}: 否
*/
public boolean isTerminated() {
return exec.isTerminated();
}
/**
* 请求关闭、发生超时或者当前线程中断
* <p>无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。</p>
*
* @param timeout 最长等待时间
* @param unit 时间单位
* @return {@code true}: 请求成功<br>{@code false}: 请求超时
* @throws InterruptedException 终端异常
*/
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
return exec.awaitTermination(timeout, unit);
}
/**
* 提交一个Callable任务用于执行
* <p>如果想立即阻塞任务的等待，则可以使用{@code result = exec.submit(aCallable).get();}形式的构造。</p>
*
* @param task 任务
* @param <T> 泛型
* @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回该任务的结果。
*/
public <T> Future<T> submit(Callable<T> task) {
return exec.submit(task);
}
/**
* 提交一个Runnable任务用于执行
*
* @param task 任务
* @param result 返回的结果
* @param <T> 泛型
* @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回该任务的结果。
*/
public <T> Future<T> submit(Runnable task, T result) {
return exec.submit(task, result);
}
/**
* 提交一个Runnable任务用于执行
*
* @param task 任务
* @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回null结果。
*/
public Future<?> submit(Runnable task) {
return exec.submit(task);
}
/**
* 执行给定的任务
* <p>当所有任务完成时，返回保持任务状态和结果的Future列表。
* 返回列表的所有元素的{@link Future#isDone}为{@code true}。
* 注意，可以正常地或通过抛出异常来终止已完成任务。
* 如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param <T> 泛型
* @return 表示任务的 Future 列表，列表顺序与给定任务列表的迭代器所生成的顺序相同，每个任务都已完成。
* @throws InterruptedException 如果等待时发生中断，在这种情况下取消尚未完成的任务。
*/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
return exec.invokeAll(tasks);
}
/**
* 执行给定的任务
* <p>当所有任务完成或超时期满时(无论哪个首先发生)，返回保持任务状态和结果的Future列表。
* 返回列表的所有元素的{@link Future#isDone}为{@code true}。
* 一旦返回后，即取消尚未完成的任务。
* 注意，可以正常地或通过抛出异常来终止已完成任务。
* 如果此操作正在进行时修改了给定的 collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param timeout 最长等待时间
* @param unit 时间单位
* @param <T> 泛型
* @return 表示任务的 Future 列表，列表顺序与给定任务列表的迭代器所生成的顺序相同。如果操作未超时，则已完成所有任务。如果确实超时了，则某些任务尚未完成。
* @throws InterruptedException 如果等待时发生中断，在这种情况下取消尚未完成的任务
*/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws
InterruptedException {
return exec.invokeAll(tasks, timeout, unit);
}
/**
* 执行给定的任务
* <p>如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
* 一旦正常或异常返回后，则取消尚未完成的任务。
* 如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param <T> 泛型
* @return 某个任务返回的结果
* @throws InterruptedException 如果等待时发生中断
* @throws ExecutionException 如果没有任务成功完成
*/
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
return exec.invokeAny(tasks);
}
/**
* 执行给定的任务
* <p>如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
* 一旦正常或异常返回后，则取消尚未完成的任务。
* 如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param timeout 最长等待时间
* @param unit 时间单位
* @param <T> 泛型
* @return 某个任务返回的结果
* @throws InterruptedException 如果等待时发生中断
* @throws ExecutionException 如果没有任务成功完成
* @throws TimeoutException 如果在所有任务成功完成之前给定的超时期满
*/
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws
InterruptedException, ExecutionException, TimeoutException {
return exec.invokeAny(tasks, timeout, unit);
}
/**
* 延迟执行Runnable命令
*
* @param command 命令
* @param delay 延迟时间
* @param unit 单位
* @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在完成后将返回{@code null}
*/
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
return scheduleExec.schedule(command, delay, unit);
}
/**
* 延迟执行Callable命令
*
* @param callable 命令
* @param delay 延迟时间
* @param unit 时间单位
* @param <V> 泛型
* @return 可用于提取结果或取消的ScheduledFuture
*/
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
return scheduleExec.schedule(callable, delay, unit);
}
/**
* 延迟并循环执行命令
*
* @param command 命令
* @param initialDelay 首次执行的延迟时间
* @param period 连续执行之间的周期
* @param unit 时间单位
* @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在取消后将抛出异常
*/
public ScheduledFuture<?> scheduleWithFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
return scheduleExec.scheduleAtFixedRate(command, initialDelay, period, unit);
}
/**
* 延迟并以固定休息时间循环执行命令
*
* @param command 命令
* @param initialDelay 首次执行的延迟时间
* @param delay 每一次执行终止和下一次执行开始之间的延迟
* @param unit 时间单位
* @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在取消后将抛出异常
*/
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
return scheduleExec.scheduleWithFixedDelay(command, initialDelay, delay, unit);
}
}