线程池的几种使用方式介绍
一、线程池的优点
关于线程池的使用优点网络上介绍的有很多，可以归结为以下几点：
1.减少在创建和销毁线程上所花的时间及系统资源的开销。
2.提高线程的可管理性，对线程进行统一的分配、调优和监控，从而也提高相应速度。
二、线程池的UML图和使用方式
线程池的UML图如下，使用线程池的方式总共有三种，下面将对这三种方式进行分析和说明。
2.1 第二种方式
由于第一种方式是通过用第二种方式的构造函数创建的，因此在介绍第一种方式前，先对第二种方式进行介绍。
ThreadPoolExecutor的构造函数及参数说明如下
|
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
|
corePoolSize：线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize；如果当前线程数为corePoolSize，继续提交的任务会被保存到阻塞队列中，等待被执行；如果执行了线程池的prestartALLCoreThreads()方法，线程池会提前创建并启动所有核心线程。
maximumPoolSize：线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize；
keepAliveTime：线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间；默认情况下，该参数只在线程数大于corePoolSize时才有用；
unit：keepAliveTime的单位
workQueue：用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供了如下队列模式；
1、ArrayBlockingQueue 一个基于数组结构的阻塞队列，此队列按FIFO原则对元素进行排序。
2、LinkedBlockingQueue 一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。今天工厂方法Executors.newFixedThreadPool()使用了这个队列。
3、SynchronousQueue一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法
Executors.newCachedThreadPool使用了这个队列。
4、PriorityBlockingQueue一个具有优先级的无限阻塞队列。
threadFactory
：线程工厂，用于创建线程，一般用默认的即可。也可以通过线程工厂给每个创建出来的线程设置更有意义的名字。
handler
：拒绝策略，当队列和线程池都满了，说明线程池出于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。策略模式有其它如下：
- AbortPolicy：直接抛出异常，阻止系统正常工作。
- CallerRunsPolicy：只要线程未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
- DiscardOldestPolicy：该策略将丢弃最老的一个请求，也就是即将被执行的一个人任务，并尝试再次提交当前任务。
- DiscardPolicy：该策略默默的丢弃无法处理对
- 当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。
2.2 第二种方式的使用
下面的代码摘取自OKHttp库中的代码，通过对
ThreadPoolExecutor设置
参数构造一个线程池。
|
public synchronized ExecutorService executorService() {
if (executorService == null) {
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue
}
return executorService;
}
|
2.3 第一种方式
第一种方式是通过工厂模式将线程池的创建从用户的new操作中解耦了，第一种方式创建的线程池的类型有如下：
1.初始化一个指定线程数的线程池，使用LinkedBlockingQueue作为阻塞队列，不过当线程池没有可执行任务时，也不会释放线程。
|
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue
}
|
同上初始一个指定数量的线程池，但是会要求传入一个自定义的线程工厂。
|
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue
threadFactory);
}
|
2.初始化一个可以缓存线程的线程池，默认缓存60是，线程池的线程数可到达interge.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列。和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程空闲时间超过KeepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销。
|
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue
threadFactory);
}
|
所以，在使用该线程池时，一定要注意控制并发的任务数，否则创建大量的线程可能导致严重的性能问题。
3.初始化的线程池中只有一个线程，如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行，内部使用LinkedBlockingQueue作为阻塞队列。
|
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue
}
|
4.初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据。
|
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
|
2.4 第三种方式
第三种方式通过定义一个ExecutorService的实现，在该实现中完成对ExecutorService和Executor接口的实现。
1.关键接口函数execute的实现
|
public void execute(Runnable runnable) {
if (mIsShutdown) {
return;
}
mQueue.add(runnable);
synchronized (mRunningThreads) {
if (mRunningThreads.size() < mMaxThreadNum) {
RecyclableThread thread;
if (mThreadPoolName != null) {
thread = new WorkerableThread(mThreadPoolName
+ "-" + mThreadNum.getAndIncrement());
} else {
thread = new WorkerableThread();
}
mRunningThreads.add(thread);
thread.start();
}
}
}
|
2.
WorkerableThread
类的定义
|
private final class WorkerableThread extends Thread {
private Runnable mRunnable;
WorkerableThread() {
super();
}
WorkerableThread(String name) {
super(name);
}
@Override
public void run() {
Runnable r = null;
while (isRunning) {// 注意，若线程无效则自然结束run方法，该线程就没用了
synchronized (taskQueue) {
while (isRunning && taskQueue.isEmpty()) {// 队列为空
try {
taskQueue.wait(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (!taskQueue.isEmpty())
r = taskQueue.remove(0);// 取出任务
}
if (r != null) {
r.run();// 执行任务
}
finished_task++;
r = null;
}
}
// 停止工作，让该线程自然执行完run方法，自然结束
public void stopWorker() {
isRunning = false;
}
private Runnable getRunnable() {
return mRunnable;
}
}
|
附上一份自定义线程池的实现连接参考：https://www.cnblogs.com/kinghitomi/archive/2012/01/19/2327418.html