线程池
前言
本章简单概括线程池相关的一些概念和类，以及如何使用线程池，线程池的原理是什么。
概述
- 什么是线程池：线程池是指管理一组同构工作线程的资源池。
- 为什么要使用线程池：随意创建线程会带来三大问题：开销高、系统资源消耗大、破坏稳定性，所以需要通过一个构造程序来进行统一管理。
- 线程是一个重量级对象，频繁创建和销毁线程需要产生巨大的系统资源开销；
- 当线程创建数超过可用处理器的线程数时，线程会闲置，闲置的线程会占用大量的内存空间，给垃圾回收器造成压力，且大量线程在竞争共享资源时也会产生其他的性能开销，严重的会导致整个应用程序崩溃；
- 使用的好处：
- 重用现有的线程而不是创建新线程，减少开销(线程是一个重量级对象，线程频繁创建和销毁需要产生巨大开销)；
- 大部分情况下工作线程已经存在，当请求到达时可以直接执行任务而不用等待再创建线程，提高了响应性；
- 适量调整线程池的大小，能够保证性能最大化，同时防止创建过多线程而导致内存不足。
基础类说明
Runnable
Runnable表示无返回值的任务
@FunctionalInterface
public interface Runnable {
//当使用对象实现接口 Runnable 创建线程时，启动线程会导致在该单独执行的线程中调用对象的方法 run 。
public abstract void run();
}
Callable
Callable表示有返回值的任务
@FunctionalInterface
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
Future
Future表示一个任务的生命周期(创建、提交、开始执行、完成)，并提供了相应的方法来判断任务是否已经完成或取消、获取任务的结果、取消任务等
public interface Future<V> {
//取消任务（已提交但尚未开始执行的任务可以取消；已开始执行的任务，只有当它们能响应中断时才能取消；已完成的任务取消不会有任何影响）
boolean cancel(boolean mayInterruptIfRunning);
//任务是否已经取消
boolean isCancelled();
//任务是否已经完成
boolean isDone();
//获取任务的结果（任务已成功执行完成：立即返回结果；任务执行中：阻塞等待执行结果；任务取消或异常：抛出异常）
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
Executor
Executor表示执行已提交Runnable任务的对象。
public interface Executor {
void execute(Runnable command);
}
ExecutorService
ExecutorService是Executor的扩展类，管理Executor的生命周期（运行、关闭、已终止），并扩展了带返回结果的提交任务方法。
public interface ExecutorService extends Executor {
//平缓的关闭线程池，同时等待已提交的任务执行完成，对于新提交的任务提交到RejectExecutionHandler
void shutdown();
//暴力的关闭线程池，同时取消所有正在执行的任务，并且不再处理工作队列中的任务
List<Runnable> shutdownNow();
//检测是否关闭/终止
boolean isShutdown();
boolean isTerminated();
//等待ExecutorService到达终止状态，
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
//提交任务并返回执行结果Future对象
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
//执行一批任务，在全部完成后返回结果
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException;
//执行一批任务，返回已成功完成的任务
<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
ThreadFactory
当线程池需要线程时，都是通过ThreadFactory来完成。默认的线程工厂方法将创建一个新的、非守护的线程，并且不包含特殊的配置信息。
public interface ThreadFactory {
Thread newThread(Runnable r);
}
线程池详细说明
线程池具体实现类为ThreadPoolExecutor，继承AbstractExecutorService类，AbstractExecutorService类实现了ExecutorService类
设置线程池的大小
- 线程池的理想大小取决于被提交任务的类型以及所部署系统的特性。在代码中通常不固定线程池的大小，而应该通过某种配置机制来提供，或者根据Runtime.getRuntime().availableProcessors()来动态计算；
- 线程池过大，大量的线程在相对较少的CPU和内存资源上相互竞争，这不仅会导致更高的内存使用量，还可能耗尽资源；线程池过小，将导致存在许多空闲的处理器线程，降低了吞吐率；
- 要想正确地设置线程池的大小，必须分析计算环境、资源预算、任务的特性（计算密集型、IO密集型、两者皆是）。
- 计算公式：N=cpuN * cpuU * (1+W/C)
（其中N=线程池大小，cpuN=cpu线程数、cpuU=CPU利用率、W=等待时间、C=计算时间） - 经验：计算密集型
N=cpuN+1；I/O密集型N=cpuN*2+1
创建线程池
使用ThreadPoolExecutor构造方法创建
构造方法
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler){
if (corePoolSize < 0 || maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize || keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ? null : AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
参数说明
- corePoolSize：核心线程数，线程被创建后不会被回收
- maximumPoolSize：最大线程数，线程池中可同时活动的最大线程数，线程空闲后过一段时间会被回收
- keepAliveTime：非核心线程数空闲后的存活时间，超过这个时间会被标记为可回收
- unit：时间单位TimeUnit
- workQueue：任务阻塞队列，若核心线程数满，则任务优先进入队列中排队等待执行（强烈建议使用有界队列）
- 根据特定场景选择合适的阻塞队列，如：需要按优先级排序的使用PriorityBlockingQueue，需要同步执行的使用SynchronousQueue，无界使用LinkedBlockingQueue，有界使用ArrayBlockingQueue或设定初始容量的LinkedBlockingQueue
- threadFactory：创建线程的工厂类，可选择使用默认
Executors.defaultThreadFactory()或者自定义参考DefaultThreadFactory类实现 - handler：饱和策略RejectedExecutionHandler，当工作队列和最大线程数均已满时提交的任务会被执行饱和策略。
- AbortPolicy：终止策略；默认策略，直接抛RejectedExecutionExcetion异常
- DiscardPolicy：丢弃策略；丢弃无法处理的工作任务
- DiscardOldestPolicy：丢弃最旧策略；丢弃工作队列头的任务，然后在工作队列尾添加新的任务。（不建议在FIFO队列中使用此策略，因为会抛弃优先级最高的任务）**
- CallerRunsPolicy：调用者运行策略，使用主线程去执行工作任务。（会导致主线程一段时间内不能提交任何任务，从而使得工作者线程有时间来处理完正在执行的任务）
- 自定义RejectedExecutionHandler：扩展RejectedExecutionHandler接口（推荐）
使用Executors静态工厂方法创建
线程池的静态工厂类，用于快速创建线程。由于Executors提供的很多方法默认都是使用的无界队列，高负载情境下，无界队列很容易导致OOM（不建议使用，推荐自定义线程池类）
- newCacheThreadPool：创建不限定线程数的线程池，使用SynchronousQueue
- newFixedThreadPool：创建固定线程数的线程池，使用LinkedBlockingQueue
- newScheduleThreadPool：创建延时执行的线程池，使用DelayedWorkQueue
- newSingleThreadExecutor：创建单个线程的线程池，使用LinkedBlockingQueue
- newSingleThreadScheduledExecutor：创建核心线程数为1，最大线程数为Integer.MAX_VALUE的延时线程的线程池，使用了DelayedWorkQueue
- newWorkStealingPool：创建任务抢占式(work-stealing工作窃取)的ForkJoinPool，jdk1.8版本新增
使用线程池
创建全局线程池类
package com.alan.module.demo.concurrent;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 定制化全局线程池
* 最大容量为2000
*
* @author jiangfengan
*/
public class MyThreadPoolExecutor extends ThreadPoolExecutor {
private final static int systemSize = Runtime.getRuntime().availableProcessors();
private final static int corePoolSize = systemSize + 1;
private final static int maximumPoolSize = systemSize * 2;
private final static long keepAliveTime = 1L;
private final static TimeUnit timeUnit = TimeUnit.MILLISECONDS;
private final static int MAX_CAPACITY = 2000;
private final static BlockingQueue workQueue = new LinkedBlockingQueue(MAX_CAPACITY);
private final static MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor(corePoolSize
, maximumPoolSize, keepAliveTime, timeUnit, workQueue, new MyThreadFactory(), new MyRejectedExecutionHandler());
private MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit
, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
/**
* 静态工厂方法构建单例对象
*/
public static MyThreadPoolExecutor getInstance() {
return myThreadPoolExecutor;
}
/**
* 定制化线程工厂
* 仅设置名字可以直接使用 new ThreadFactoryBuilder().setNameFormat("my-pool-").get()
*/
static class MyThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
MyThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "my-pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon()) {
t.setDaemon(false);
}
if (t.getPriority() != Thread.NORM_PRIORITY) {
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
}
/**
* 定制化拒绝策略处理类
*/
static class MyRejectedExecutionHandler implements RejectedExecutionHandler {
public MyRejectedExecutionHandler() {
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
throw new RejectedExecutionException(String.format("任务%s被拒绝%s", r.toString(), executor.toString()));
}
}
}
提交任务
//无返回值提交
executor.execute(()-> System.out.println("Hello"));
//有返回值提交
executor.submit(()-> System.out.println("Hello"));
//有返回值提交
executor.submit(()-> "Hello");
关闭线程池
//平缓的关闭线程池，同时等待已提交的任务执行完成，对于新提交的任务提交到RejectExecutionHandler
executor1.shutdown();
//暴力的关闭线程池，同时取消所有正在执行的任务，并且不再处理工作队列中的任务
executor1.shutdownNow();
线程池源码分析
整体流程
1. 提交任务到线程池
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
//1. Runnable转换为FutureTask
RunnableFuture<Void> ftask = newTaskFor(task, null);
//2. 执行FutureTask
execute(ftask);
//3. 返回结果
return ftask;
}
public void execute(Runnable command) {
//检验任务是否为空
if (command == null)
throw new NullPointerException();
//获取线程池
int c = ctl.get();
//1. 当前工作线程数小于核心线程数
if (workerCountOf(c) < corePoolSize) {
//创建一个核心线程，执行任务
if (addWorker(command, true))
return;
//若创建核心线程失败，则重新获取线程池，到后续逻辑中处理
c = ctl.get();
}
//2. 当前核心线程数已满
//如果是运行状态，将工作任务添加到工作队列中
if (isRunning(c) && workQueue.offer(command)) {
//再次获取线程池
int recheck = ctl.get();
//若此时线程池已不是运行状态，则需要进行回滚入队操作
if (! isRunning(recheck) && remove(command))
//回滚成功后执行拒绝策略
reject(command);
//若线程池正常运行，查看工作线程数是否为0
else if (workerCountOf(recheck) == 0)
//当工作线程数全部为0时，创建一个非核心线程
addWorker(null, false);
}
//3 工作队列已满，尝试创建非核心线程处理任务
else if (!addWorker(command, false))
//创建非核心线程失败，说明线程池已满，执行饱和策略
reject(command);
}
2. 创建线程执行任务
private boolean addWorker(Runnable firstTask, boolean core) {
//1. 工作线程数加1
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//2. 开始创建线程执行任务
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
//添加任务到实例
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive())
throw new IllegalThreadStateExceptio();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
//添加工作成功
workerAdded = true;
}
} finally {
mainLock.unlock();
}
//3. 启动线程执行任务
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
3. 线程执行任务
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//获取任务成功执行
while (task != null || (task = getTask()) != null) {
w.lock();
//中断校验
if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted())
wt.interrupt();
//执行任务
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
4. 获取任务
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
//线程回收条件：1.若线程池已停止；2.线程池已关闭，工作队列为空；3.工作线程已超出最大线程数；4.工作线程在等待任务时超时，不是最后一个线程
for (;;) {
//获取线程池和线程池状态
int c = ctl.get();
int rs = runStateOf(c);
//若线程池已停止 或 线程池已关闭，工作队列为空
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
//回收线程，获取任务为null
decrementWorkerCount();
return null;
}
//获取工作线程数
int wc = workerCountOf(c);
//获取线程是否需要回收标识（设置为需要回收的、超过核心线程数的；true表示需要回收）
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//（ 工作线程已超出最大线程数 或者 空闲线程）并且（不是最后一个线程 或者 是最后一个线程且工作队列已空）
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
//尝试回收线程，获取任务为null
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
//获取任务：需要回收的线程执行poll方法获取任务，不需要回收的线程执行take方法获取任务
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;//获取任务超时，说明当前没有任务需要处理，线程空闲
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
