线程池：Executor框架源码解析（上）

最新推荐文章于 2022-10-26 15:17:17 发布
最新推荐文章于 2022-10-26 15:17:17 发布
阅读量626 收藏
点赞数 1
分类专栏： Java源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jakob_Hu/article/details/103231397
版权

Executor框架使用

Java内部提供了线程池Executor框架，其功能比之前笔记中自实现的简易线程池更加全面。

1.整体架构

Executor框架的整体架构如下，
image

接口/类说明
Executor该接口只有一个execute方法，目的是将任务提交和执行解耦
ExecutorService该接口对Executor接口进行了拓展，定义了对线程池中线程的管理方法
AbstractExecutorService对ExecutorService接口中部分方法的实现
ThreadPoolExecutor线程池的最终实现，实现了线程池工作的完整机制，是整个框架的重点
ForkJoinPool实现了Fork/Join模式的线程池
ScheduleExecutorService对ExecutorService进行了拓展，定义了延迟执行和周期执行任务的方法
ScheduleThreadExecutorService在继承ThreadPoolExecutorService的基础上对ScheduleExecutorService接口进行了实现

2.源码解析

Executor接口

该接口只有一个方法executor，传入参数是 Runnable类型，

public interface Executor {
    void execute(Runnable command);
}

ExecuorService接口

该接口对 Executor接口进行了拓展，定义了线程池管理和更多执行任务的方法，
image
重要的方法说明，

方法说明
shutdown终止ExecutorService，不再接收和执行新的任务，已经执行的任务会被执行完
shutdownNow立刻终止ExecutorService，不再接收和执行新的任务，已经执行的任务也会终止(但不保证能够被终止)
submit对execute方法的拓展，返回一个 Future类对象
invokeAll执行一组任务，所有任务都返回或者 timeout 的时候，invokeAll 方法返回执行结果列表。该方法一旦返回结果，没有完成的任务则被取消
invokeAny执行一组任务，任意一个任务有返回时，invokeAny 返回该任务的执行结果。其余没有完成的任务则被取消。

AbstractExecutorService类

该抽象类封装了 Executor的很多通用功能，最重要的两个方法是newTaskFor和submit方法。

1）构建任务—newTaskFor方法

该方法的实现有两种形式，分别针对 Runnable和 Callable接口的实现类，

// 传入参数为 Runnable
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

// 传入参数为 Callable
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

返回值的类型是 FutureTask类对象，属于 RunnableFuture接口的实现类。该类的具体实现参见笔记，可简单理解为将Runnable和Callable统一封装为Callable对象。

2）构建任务并执行—submit方法

该方法的实现同样依据传入的参数是 Runnable和Callable分为两种，

// 提交无返回值的任务
public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    // ftask 其实是 FutureTask
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

// 提交有返回值的任务
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    // ftask 其实是 FutureTask
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

对该抽象类进行如下说明，

  1. AbstractExecutorService类最主要的是实现了submit方法，用于提交和执行任务。其内部调用了自身实现的newTaskFor方法和Executor接口定义的execute方法。
    在newTaskFor方法中构建的任务是FutureTask类对象，属于RunnableFuture类的子类。RunnableFuture实现类Runnable接口和Future接口，所以可以被传入 Executor接口的execute方法
  2. execute方法的具体实现是在该类的子类 ThreadPoolExecutor中

ThreadPoolExecutor类*

1）类注释

ThreadPoolExecutor类的注释很多，关键注释如下，

  1. 线程池解决两个问题，通过减少任务间的调度开销提高大量任务时的执行性能(主要是线程被重复使用)；提供一种方式管理线程的消费，维护基本数据并对已完成任务进行统计
  2. Executors 为常用的场景设定了可直接初始化线程池的方法，比如
    Executors#newCachedThreadPool 无界的线程池，并且可以自动回收；
    Executors#newFixedThreadPool 固定大小线程池；
    Executors#newSingleThreadExecutor 单个线程的线程池等
  3. 为了在各种上下文中使用线程池，线程池提供可供扩展的参数设置，
    coreSize：当新任务提交时，发现运行的线程数小于 coreSize，一个新的线程将被创建，即使这时候其它工作线程是空闲的，可以通过 getCorePoolSize 方法获得 coreSize；
    maxSize：当任务提交时，coreSize < 运行线程数 <= maxSize，但队列没有满时，任务提交到队列中，如果队列满了，在 maxSize 允许的范围内新建线程
  4. 默认的，core threads 需要到任务提交后才创建的，但可以分别使用 prestartCoreThread和prestartAllCoreThreads 两个方法来提前创建一个、所有的 core threads
  5. 新的线程被默认 ThreadFactory 创建时，优先级会被限制成 NORM_PRIORITY，默认会被设置成非守护线程，这个和新建线程的继承是不同的
  6. Keep-alive times 参数的作用，
    i. 如果当前线程池中有超过 coreSize 的线程；
    ii. 并且线程空闲的时间超过 keepAliveTime，当前线程就会被回收，这样可以避免线程没有被使用时的资源浪费
  7. 如果设置 allowCoreThreadTimeOut 为 ture 的话，core thread 空闲时间超过 keepAliveTime 的话，也会被回收
  8. 线程池新建时，有多种任务队列可供选择，
    i. SynchronousQueue，为了避免任务被拒绝，要求线程池的 maxSize 无界，缺点是当任务提交的速度超过消费的速度时，可能出现无限制的线程增长；
    ii. LinkedBlockingQueue，无界队列，未消费的任务可以在队列中等待；
    iii. ArrayBlockingQueue，有界队列，可以防止资源被耗尽
  9. 在 Executor 已经关闭或对最大线程和最大队列都使用饱和时，可以使用 RejectedExecutionHandler 类进行异常捕捉，有如下四种处理策略：ThreadPoolExecutor.AbortPolicy、ThreadPoolExecutor.DiscardPolicy、ThreadPoolExecutor.CallerRunsPolicy、ThreadPoolExecutor.DiscardOldestPolicy
    10.线程池提供了很多可供扩展的钩子函数，
    i. 提供在每个任务执行之前beforeExecute和执行之后 afterExecute 的钩子方法，主要用于操作执行环境，比如初始化 ThreadLocals、收集统计数据、添加日志条目等；
    ii. 如果在执行器执行完成之后想干一些事情，可以实现 terminated 方法
    如果钩子方法执行时发生异常，工作线程可能会失败并立即终止

2）ThreadPoolExecutor重要属性

用户可控制的属性都是 volatile 关键字修饰的，

属性说明
private final AtomicInteger ctl线程池状态控制字段由两部分组成，工作线程数wc和线程池状态rs，具体见表格下方说明
volatile long completedTasks已完成任务的计数
private long completedTaskCount已经完成的任务数
private int largestPoolSize线程池最大容量
private volatile ThreadFactory threadFactory可以使用 threadFactory 创建 线程
private volatile RejectedExecutionHandler handler饱和或者运行中拒绝任务的 handler 处理类
private volatile long keepAliveTime线程存活时间设置
private volatile boolean allowCoreThreadTimeOut设置 true 的话，核心线程空闲 keepAliveTime 时间后，也会被回收
private volatile int corePoolSize核心线程数目
private volatile int maximumPoolSize用户设定的线程池最大线程数
private static final RejectedExecutionHandler defaultHandler默认的拒绝策略，默认是 AbortPolicy类对象
private final BlockingQueue workQueue任务队列，利用队列的阻塞的特性
private final HashSet workers包含线程池中所有的工作线程，元素是Worker类对象
private final ReentrantLock mainLock可重入锁对象，控制对workers队列的访问
private final Condition termination可重入锁对象mainLock的条件队列，控制对workers队列的访问
工作线程数—workerCount

相关属性和方法，

private static final int COUNT_BITS = Integer.SIZE - 3;			// 29
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;	// =(2^29)-1=536870911

private static int workerCountOf(int c) { 
	return c & CAPACITY; 
}
线程池状态—runState

线程池相关状态，

private static final int RUNNING    = -1 << COUNT_BITS;		//-536870912
private static final int SHUTDOWN   =  0 << COUNT_BITS;		//0
private static final int STOP       =  1 << COUNT_BITS;		//-536870912
private static final int TIDYING    =  2 << COUNT_BITS;		//1073741824
private static final int TERMINATED =  3 << COUNT_BITS;		//1610612736

private static int runStateOf(int c) { 
	return c & ~CAPACITY; 
}

线程池状态转换，
image

状态说明
RUNNING（-536870912）接受新任务或者处理队列里的任务。
SHUTDOWN（0）不接受新任务，但仍在处理已经在队列里面的任务。执行 shutdown()和finalize()方法后从 RUNNING到 SHUTDOWN状态
STOP（-536870912）不接受新任务，也不处理队列中的任务，对正在执行的任务进行中断。执行 shutdownNow()方法后从 RUNNING到 STOP状态
TIDYING（1073741824）所以任务都被中断，workerCount 是 0，整理状态。SHUTDOWN/STOP -> TIDYING -> workerCount=0
TERMINATED（1610612736）执行terminated() 方法执行完成时从 TIDYING到 TERMINATED
线程池状态控制字段—ctl

ctl变量由工作线程数和线程池状态共同构成，该变量是一个 AtomicInteger 的类，就是让保存的 int 变量的更新都是原子操作，保证线程安全。

private static int ctlOf(int rs, int wc) { 
	return rs | wc; 
}

ctlOf方法就是组合运行状态和工作线程数量，该方法是通过按位或的方式来实现的。这里把一个 int 变量拆成两部分来用。前面3位用来表示状态，后面29位用来表示工程线程数量。所以，工作线程数量最大不能超过 2 29 − 1 2^{29}-1 229−1。
image

该变量一会儿用来获取线程数量workerCountOf方法，一会儿又用来判断线程池是否处于运行状态isRunning方法。这两个方法源码如下，

// 这两个方法的参数c就是当前线程池 ctl的值
private static int workerCountOf(int c) { 
	return c & CAPACITY;
}

private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}

第一个方法中又多出一个CAPACITY常量，

private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

CAPACITY的值为 000111...111 000111...111 000111...111（共计32位）。

workerCountOf方法中按位与之后去掉了前面3位，保留了后面29位。所以，拿到的就是工作线程的数量。

isRunning 方法中，直接拿 ctl 的值和 SHUTDOWN 作比较。首先明确在 RUNNING 状态下，ctl 的值是什么样的，

  • 初始状态，ctl 的值是 11100000... … 00000000 11100000 ... … 00000000 11100000...…00000000，表示 RUNNING 状态，和0个工作线程。
  • 每创建一个新线程，都把 ctl 加1。当有5个工作线程时，ctl 的值是 11100000... … 00000101 11100000 ... … 00000101 11100000...…00000101。

在 RUNNING状态下，ctl 始终是负值，而 SHUTDOWN 是0，所以可以通过直接比较 ctl 的值来确定状态。

3）构造方法

一般并不直接通过ThreadPoolExecutor的构造方法创建线程池，而是通过Executors类提供的工厂函数进行创建，

Executors.newFixedThreadPool(10)

通过 Executors 的工厂方法来创建ThreadPoolExecutor对象。Executor 提供了多种工厂方法创建线程池。其实根本是调用 ThreadPoolExecutor 构造方法时传入参数不同。以newFixedThreadPool 方法为例，源代码如下，

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

底层调用的 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线程池核心线程数量，即最小线程数量。不设置allowCoreThreadTimeout时，核心线程一直存活
maximumPoolSize线程池最大线程数量，受限于CAPACITY的大小
workQueue一个阻塞队列，用于保存线程池要执行的所有任务
threadFactory规范了生成的线程，避免了手动调用new Thread()时创建出来的线程的差异，创建得到的线程具有连续的线程号码

构造过程中没有启动任何线程，避免对资源的浪费。

4）内部封装线程—Worker类

Worker封装了线程，是线程池中的工作单元。该类继承了 AQS，同时实现了 Runnable。

类属性

该类的属性如下，

// 该worker对象中封装的线程，如果是 null说明ThreadFactory构建线程失败
final Thread thread;
// 需要执行的任务
Runnable firstTask;
// 记录每个线程完成的任务数目
volatile long completedTasks
构造方法

构造方法如下，

Worker(Runnable firstTask) {
    setState(-1); 
    this.firstTask = firstTask;
    this.thread = getThreadFactory().newThread(this);
}

创建 thread 时，Worker 对象将自己作为 Runnable 的实现传入了 thread 中。线程池在执行时调用的 t.start()，实际上运行的是 t 所属 Worker类的run方法。

run方法

worker 的 run 方法如下,

public void run() {
    runWorker(this);
}

上面的代码中，runWorker方法是外部类 ThreadPoolExecutor的方法，之后会讲解。

对Worker类的理解
  1. Worker类像是任务代理，是线程池中最小的执行单位，对线程池中的工作线程进行了良好的封装
  2. Worker 本身也实现了 AQS，所以其本身也是一个锁，其在执行任务的时候，会锁住自己，任务执行完成之后，会释放自己
  3. 在 Worker 初始化时 this.thread = getThreadFactory ().newThread (this) 这行代码比较关键。它把当前 Worker 作为线程的构造器入参，在后续的实现中会发现这样的代码：Thread t = w.thread;t.start()，此时的 w 是 Worker 的引用，此处 t.start 实际上执行的就是 Worker 的 run 方法
Jakob_Hu
关注
专栏目录
【java】线程 ExecutorService 原理 源码 解释
九师兄
04-16 308
1.世界 1.概述 2. 继承体系 3.源码解析 概要预览 public interface ExecutorService extends Executor { void shutdown(); List<Runnable> shutdownNow(); boolean isShutdown(); boolean isTerminated(); boolean awaitTermination(long timeout, TimeUnit unit
线程池Executor框架解读
桐花思雨
05-30 516
目录`Executor` 整体架构 Executor 整体架构 接口/类说明Executor该接口只有一个execute方法，目的是将任务提交和执行解耦ExecutorService该接口对Executor接口进行了拓展，定义了对线程池中线程的管理方法AbstractExecutorService对ExecutorService接口中部分方法的实现ThreadPoolExecutor线程池的最终实现，实现了线程池工作的完整机制，是整个框架的重点ForkJoinPool实现了Fork/Join模式的线程池S
线程池：Executor框架源码解析（下）
Jakob_Hu的博客
11-25 251
线程池：Executor框架源码解析2.源码解析ThreadPoolExecutor类*5）任务执行—execute方法6）新建Worker并执行任务—addWorker方法更新Worker的数量添加worker到workers集合中并且启动worker持有的线程7）线程任务实际运行—runWorker方法总结1）submit方法整体流程2）线程池整体图 2.源码解析 ThreadPoolExec...
java线程池 - Executor框架源码解析
大佬请赐教
02-05 264
为何使用线程池技术 1.线程是重量级资源，线程创建、销毁需要耗费较大的性能，因此重复使用线程能极大地改善程序性能。 2.线程并不是越多越好，线程数量和性能呈抛物线关系，而且通过new Thread方式创建的线程无法很好地进行管控。 3.new Thread方式创建的线程不利于扩展，比如定时、定期执行任务，线程中断。线程池如何提升性能 主要是避免了线程的创建、销毁这部分时间的耗费 1.普通线程执行某...
Executor源码解析
carson0408的博客
05-10 806
        任务执行有两种方案，一种是串行执行任务，第二种就是为每个任务创建一个线程；串行执行的问题在于其糟糕的响应性和吞吐量，而后者的问题在于资源管理的复杂性，为每个任务分配一个线程会出现耗内存甚至系统崩溃的问题。因此引入了线程池的概念为合理缓解两者存在的问题。而线程池通过实现Executor框架中的接口来进行工作，首先来看下图的Executor框架的接口以及类的结构图：        如上...
【并发编程】Executor线程池框架-图文源码详解
opi
03-19 342
目录 0框架类图 1. Executors工具类 2 ThreadPoolExecutor 2.1API常用方法 2.1.1 构造方法 2.1.2 核心方法execute(Runnable r) 2.1.3 addWorker创建工作线程 2.2组件解析 2.2.1 worker 2.2.2 ThreadFactory 2.2.3BlockingQueue 0框...
（八）线程池与Executor 框架
nimab1987的专栏
11-04 153
111
Java线程池实现原理与源码解析（JDK11）
qq_39736103的博客
10-11 304
线程池优势 线程池能够对线程进行统一分配，调优和监控： - 降低资源消耗（线程无限制地创建，然后使用完毕后销毁） - 提高响应速度（无须创建线程） - 提高线程的可管理性 线程池源码关系图 ScheduledThreadPool 初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据。 工作原理 当一个任务提交至线程池之后， ...
JUC Executor-ThreadPoolExecutor（线程池） 源码解析
淦淦淦！
03-04 426
通过Java并发编程实战（进阶篇 - 下）对 Executor 框架的简介，已经基本了解了 Executor 框架的结构和成员，本篇讲解 Executor 框架中任务执行单元 ThreadPoolExecutor（线程池）工作原理。 前言 提出三个问题来更好的了解 ThreadPoolExecutor： 什么是线程池？ 线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行...
Java线程池深度剖析：源码背后的内部工作机制揭秘
[Java线程池深度剖析：源码背后的内部工作机制揭秘](https://ucc.alicdn.com/pic/developer-ecology/xciijj5xqvucg_9d019a4844b34a5ab0c1c2c6337744d1.png?x-oss-process=image/resize,s_500,m_lfit) # 1. Java...
Java线程池源码解析
最新发布
04-23
Java提供了Executor框架，实现线程池的功能。其中，ThreadPoolExecutor类是Java内置的线程池实现类，具有灵活性和优秀的封装性，可以满足大多数并发编程需求。使用ThreadPoolExecutor时需要注意一些参数： ...
调度线程池ScheduledThreadPoolExecutor源码解析
m0_71777195的博客
10-26 513
可以用来很方便实现我们的调度任务，具体使用可以参考调度线程池ScheduledThreadPoolExecutor的正确使用姿势这篇文章，那大家知道它是怎么实现的吗，本文就带大家来揭晓谜底。
Future、ExecutorService 源码解析
章全蛋的博客
07-09 203
Future、ExecutorService 源码解析 Thread 或者 Runnable 方法开启的线程是没有返回值，如果我们需要子线程计算，取得结果后返回，可以用 Callable。 整体架构 关于线程 API 之间关系的依赖图： 我们首先看一个 demo，这个场景说的是我们往线程池里面提交一个有返回值的线程，代码如下： public static void main(String[] args) throws ExecutionException, InterruptedException {
线程：Future、ExecutorService源码解析
Jakob_Hu的博客
11-08 539
Future、ExecutorService源码解析1.整体架构2.Callable接口3.FutureTask类Future接口RunnableFuture接口统一Callable和Runnable1）FutureTask类定义2）FutureTask类属性3）FutureTask构造器4）Runnable适配CallableFutureTask对任务的管理1）get方法2）run方法3）can...
ExecutorService源码解读
weixin_36894490的博客
07-07 413
ExecutorService源码阅读ExecutorService接口详解[源码版本]jdk 1.8[解读]ExecutorService关闭方法概述[举例1]代码示例[解读]ExecutorService任务执行方法概述[解读]Executors工厂方法概述[举例1]代码示例[解读]内存一致性影响接口方法详解`shutdown`方法`shutdownNow`方法`isShutdown`方法`isTerminated`方法`awaitTermination`方法`submit`方法` Future sub
Android线程池（六）AbstractExecutorService类源码解析
weifeng的博客
03-27 1413
ThreadPoolExecutor继承了AbstractExecutorService,而AbstractExecutorService又实现了ExecutorService接口。所以，根据多态，ThreadPoolExecutor可以看作是ExecutorService类型。 示例首先来看一段使用示例 ExecutorService recmdService = Executor
java多线程 ExecutorService源码分析
许诗宇的博客
04-21 221
package java.util.concurrent; import java.util.List; import java.util.Collection; /** * 一个执行器，它提供管理终止的方法，以及可以产生Future来跟踪一个或多个异步任务的进度的方法。 * * <p>ExecutorService可以被关闭，这将导致它拒绝新的任务。 * 提供了两种不同的方法来关闭ExecutorService。 * * shutdown方法允许之前提交的任务在终止前执行...
JDK源码解析---ExecutorService
gongsenlin341的博客
10-12 309
文章目录1.概述2.具体接口方法2.1 shutdown2.2 shutdownNow2.3 isShutdown2.4 isTerminated2.5 awaitTermination2.6 submit2.7 invokeAll2.8 invokeAny 1.概述 ExecutorService接口是对Executor接口的扩展，它添加了一些新功能，如支持有返回结果的任务、支持超时任务、支持取消任务、支持批量提交任务。这里的submit方法，返回类型是Future，返回后，只表示任务已提交，不代表已经执
Android线程池（五）Executors类源码解析
weifeng的博客
03-26 582
概要 // 每次只执行一个线程任务的线程池 ExecutorService singleTaskExecutor = Executors.newSingleThreadExecutor();可以看出，ThreadPoolExecutor与Executors类关系是非常密切的。在开发并发程序时，我们可能或多或少都要用到线程池来复用线程以达到较高的性能，但是我们自己写的线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值