Java源码解析 ThreadPoolExecutor 线程池

1 线程池的好处

小编整理了一些java进阶学习资料和面试题,需要资料的请加JAVA高阶学习Q群:664389243 这是小编创建的java高阶学习交流群,加群一起交流学习深造。群里也有小编整理的2019年最新最全的java高阶学习资料!

线程使应用能够更加充分合理地协调利用CPU、内存、网络、I/O等系统资源.

线程的创建需要开辟虚拟机栈、本地方法栈、程序计数器等线程私有的内存空间;

在线程销毁时需要回收这些系统资源.

频繁地创建和销毁线程会浪费大量的系统资源,增加并发编程风险.

在服务器负载过大的时候,如何让新的线程等待或者友好地拒绝服务?

这些都是线程自身无法解决的;

所以需要通过线程池协调多个线程,并实现类似主次线程隔离、定时执行、周期执行等任务.

线程池的作用包括:

●利用线程池管理并复用线程、控制最大并发数等

●实现任务线程队列缓存策略和拒绝机制

●实现某些与时间相关的功能

如定时执行、周期执行等

●隔离线程环境

比如,交易服务和搜索服务在同一台服务器上,分别开启两个线程池,交易线程的资源消耗明显要大;

因此,通过配置独立的线程池,将较慢的交易服务与搜索服务隔离开,避免各服务线程相互影响.

在开发中,合理地使用线程池能够带来3个好处

降低资源消耗通过重复利用已创建的线程,降低创建和销毁线程造成的系统资源消耗

提高响应速度当任务到达时,任务可以不需要等到线程创建就能立即执行

提高线程的可管理性线程是稀缺资源,如果过多地创建,不仅会消耗系统资源,还会降低系统的稳定性,导致使用线程池可以进行统一分配、调优和监控。

在了解线程池的基本作用后,我们学习一下线程池是如何创建线程的

2 创建线程池

首先从 ThreadPoolExecutor构造方法讲起,学习如何自定义 ThreadFactory和 RejectedExecutionHandler;

并编写一个最简单的线程池示例.

然后,通过分析 ThreadPoolExecutor的 execute和 addWorker两个核心方法;

学习如何把任务线程加入到线程池中运行.

ThreadPoolExecutor 的构造方法如下

Java源码解析 ThreadPoolExecutor 线程池_第1张图片

第1个参数: corePoolSize 表示常驻核心线程数

如果等于0,则任务执行完之后,没有任何请求进入时销毁线程池的线程;

如果大于0,即使本地任务执行完毕,核心线程也不会被销毁.

这个值的设置非常关键;

设置过大会浪费资源;

设置过小会导致线程频繁地创建或销毁.

第2个参数: maximumPoolSize 表示线程池能够容纳同时执行的最大线程数

从第1处来看,必须>=1.

如果待执行的线程数大于此值,需要借助第5个参数的帮助,缓存在队列中.

如果 maximumPoolSize=corePoolSize,即是固定大小线程池.

第3个参数: keepAliveTime 表示线程池中的线程空闲时间

当空闲时间达到 keepAliveTime时,线程会被销毁,直到只剩下 corePoolSize个线程;

避免浪费内存和句柄资源.

在默认情况下,当线程池的线程数大于 corePoolSize时, keepAliveTime才起作用.

但是当 ThreadPoolExecutor的 allowCoreThreadTimeOut=true时,核心线程超时后也会被回收.

第4个参数: TimeUnit表示时间单位

keepAliveTime的时间单位通常是TimeUnit.SECONDS.

第5个参数: workQueue 表示缓存队列

当请求的线程数大于 maximumPoolSize时,线程进入 BlockingQueue.

后续示例代码中使用的LinkedBlockingQueue是单向链表,使用锁来控制入队和出队的原子性;

两个锁分别控制元素的添加和获取,是一个生产消费模型队列.

第6个参数: threadFactory 表示线程工厂

它用来生产一组相同任务的线程;

线程池的命名是通过给这个factory增加组名前缀来实现的.

在虚拟机栈分析时,就可以知道线程任务是由哪个线程工厂产生的.

第7个参数: handler 表示执行拒绝策略的对象

当超过第5个参数 workQueue的任务缓存区上限的时候,就可以通过该策略处理请求,这是一种简单的限流保护.

友好的拒绝策略可以是如下三种:

(1 ) 保存到数据库进行削峰填谷;在空闲时再提取出来执行

(2)转向某个提示页面

(3)打印日志

2.1.1 corePoolSize(核心线程数量)

线程池中应该保持的主要线程的数量.即使线程处于空闲状态,除非设置了 allowCoreThreadTimeOut这个参数,当提交一个任务到线程池时,若线程数量

Java源码解析 ThreadPoolExecutor 线程池_第2张图片

2.1.2 maximumPoolSize(线程池最大线程数)

线程池允许创建的最大线程数

若队列满,并且已创建的线程数小于最大线程数,则线程池会再创建新的线程放入works中执行任务,CashedThreadPool的关键,固定线程数的线程池无效

若使用了无界任务队列,这个参数就没什么效果

workQueue

存储待执行任务的阻塞队列,这些任务必须是 Runnable的对象(如果是Callable对象,会在submit内部转换为Runnable对象)

runnableTaskQueue(任务队列):用于保存等待执行的任务的阻塞队列.可以选择以下几个阻塞队列.

LinkedBlockingQueue:一个基于链表结构的阻塞队列,此队列按FIFO排序元素,吞吐量通常要高于ArrayBlockingQueue.静态工厂方法Executors.newFixedThreadPool()使用了这个队列

SynchronousQueue:一个不存储元素的阻塞队列.每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于Linked-BlockingQueue,静态工厂方法Executors.newCachedThreadPool使用了这个队列

ThreadFactory:用于设置创建线程的工厂,可以通过线程工厂给每个创建出来的线程设置更有意义的名字.使用开源框架guava提供ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字,代码如下

new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();

RejectedExecutionHandler(拒绝策略) 当队列和线程池都满,说明线程池饱和,必须采取一种策略处理提交的新任务 策略默认AbortPolicy,表无法处理新任务时抛出异常 在JDK 1.5中Java线程池框架提供了以下4种策略

AbortPolicy:丢弃任务,抛出 RejectedExecutionException

CallerRunsPolicy:只用调用者所在线程来运行任务,有反馈机制,使任务提交的速度变慢)。

DiscardOldestPolicy 若没有发生shutdown,尝试丢弃队列里最近的一个任务,并执行当前任务, 丢弃任务缓存队列中最老的任务,并且尝试重新提交新的任务

DiscardPolicy:不处理,丢弃掉, 拒绝执行,不抛异常 当然,也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略.如记录日志或持久化存储不能处理的任务

  /**

    * Invokes the rejected execution handler for the given command.

    * Package-protected for use by ScheduledThreadPoolExecutor.

    */

   final void reject(Runnable command) {

       // 执行拒绝策略

       handler.rejectedExecution(command, this);

   }

handler 构造线程池时候就传的参数, RejectedExecutionHandler的实例 RejectedExecutionHandler在 ThreadPoolExecutor 中有四个实现类可供我们直接使用,当然,也可以实现自己的策略,一般也没必要。

   //只要线程池没有被关闭,由提交任务的线程自己来执行这个任务

   public static class CallerRunsPolicy implements RejectedExecutionHandler {

       public CallerRunsPolicy() { }

       /**

        * Executes task r in the caller's thread, unless the executor

        * has been shut down, in which case the task is discarded.

        *

        * @param r the runnable task requested to be executed

        * @param e the executor attempting to execute this task

        */

       public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

           if (!e.isShutdown()) {

               r.run();

           }

       }

   }

   // 不管怎样,直接抛出 RejectedExecutionException 异常

   // 默认的策略,如果我们构造线程池的时候不传相应的 handler ,则指定使用这个

   public static class AbortPolicy implements RejectedExecutionHandler {

       public AbortPolicy() { }

       /**

        * Always throws RejectedExecutionException.

        *

        * @param r the runnable task requested to be executed

        * @param e the executor attempting to execute this task

        * @throws RejectedExecutionException always

        */

       public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

           throw new RejectedExecutionException("Task " + r.toString() +

                                                " rejected from " +

                                                e.toString());

       }

   }

   // 不做任何处理,直接忽略掉这个任务

   public static class DiscardPolicy implements RejectedExecutionHandler {

       /**

        * Creates a {@code DiscardPolicy}.

        */

       public DiscardPolicy() { }

       /**

        * Does nothing, which has the effect of discarding task r.

        *

        * @param r the runnable task requested to be executed

        * @param e the executor attempting to execute this task

        */

       public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

       }

   }

   // 若线程池未被关闭

   // 把队列队头的任务(也就是等待了最长时间的)直接扔掉,然后提交这个任务到等待队列中

   public static class DiscardOldestPolicy implements RejectedExecutionHandler {

       public DiscardOldestPolicy() { }

       /**

        * Obtains and ignores the next task that the executor

        * would otherwise execute, if one is immediately available,

        * and then retries execution of task r, unless the executor

        * is shut down, in which case task r is instead discarded.

        *

        * @param r the runnable task requested to be executed

        * @param e the executor attempting to execute this task

        */

       public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

           if (!e.isShutdown()) {

               e.getQueue().poll();

               e.execute(r);

           }

       }

   }

keepAliveTime(线程活动保持时间)

线程没有任务执行时最多保持多久时间终止

线程池的工作线程空闲后,保持存活的时间。

所以,如果任务很多,并且每个任务执行的时间比较短,可以调大时间,提高线程的利用率

TimeUnit(线程活动保持时间的单位):指示第三个参数的时间单位;可选的单位有天(DAYS)、小时(HOURS)、分钟(MINUTES)、毫秒(MILLISECONDS)、微秒(MICROSECONDS,千分之一毫秒)和纳秒(NANOSECONDS,千分之一微秒)

从代码第2处来看,队列、线程工厂、拒绝处理服务都必须有实例对象;但在实际编程中,很少有程序员对这三者进行实例化,而通过Executors这个线程池静态工厂提供默认实现;

那么Exceutors与ThreadPoolExecutor是什么关系呢?

Java源码解析 ThreadPoolExecutor 线程池_第3张图片

Executors工厂类

ExecutorService 的抽象类 AbstractExecutorService提供了 submit、 invokeAll 等方法的实现;

但是核心方法 Executor.execute()并没有在这里实现.

因为所有的任务都在该方法执行,不同实现会带来不同的执行策略.

通过 Executors的静态工厂方法可以创建三个线程池的包装对象

ForkJoinPool、

ThreadPoolExecutor

ScheduledThreadPoolExecutor

● Executors.newWorkStealingPool

JDK8 引入,创建持有足够线程的线程池支持给定的并行度;

并通过使用多个队列减少竞争;

构造方法中把CPU数量设置为默认的并行度.

返回 ForkJoinPool ( JDK7引入)对象,它也是 AbstractExecutorService 的子类

Java源码解析 ThreadPoolExecutor 线程池_第4张图片

● Executors.newCachedThreadPool maximumPoolSize 最大可以至 Integer.MAX_VALUE,是高度可伸缩的线程池.

若达到该上限,相信没有服务器能够继续工作,直接OOM. keepAliveTime 默认为60秒;

工作线程处于空闲状态,则回收工作线程;

如果任务数增加,再次创建出新线程处理任务.

● Executors.newScheduledThreadPool

线程数最大至 Integer.MAX_ VALUE,与上述相同,存在OOM风险. ScheduledExecutorService接口的实现类,支持定时及周期性任务执行;相比Timer, ScheduledExecutorService 更安全,功能更强大.

与 newCachedThreadPool的区别是不回收工作线程.

● Executors.newSingleThreadExecutor

创建一个单线程的线程池,相当于单线程串行执行所有任务,保证按任务的提交顺序依次执行.

● Executors.newFixedThreadPool

输入的参数即是固定线程数;

既是核心线程数也是最大线程数;

不存在空闲线程,所以 keepAliveTime等于0.

其中使用了 LinkedBlockingQueue, 但是没有设置上限!!!,堆积过多任务!!!

Java源码解析 ThreadPoolExecutor 线程池_第5张图片

下面介绍 LinkedBlockingQueue的构造方法

使用这样的无界队列,如果瞬间请求非常大,会有OOM的风险;

Java源码解析 ThreadPoolExecutor 线程池_第6张图片

除 newWorkStealingPool 外,其他四个创建方式都存在资源耗尽的风险.

不推荐使用其中的任何创建线程池的方法,因为都没有任何限制,存在安全隐患.

Executors中默认的线程工厂和拒绝策略过于简单,通常对用户不够友好.

线程工厂需要做创建前的准备工作,对线程池创建的线程必须明确标识,就像药品的生产批号一样,为线程本身指定有意义的名称和相应的序列号.

拒绝策略应该考虑到业务场景,返回相应的提示或者友好地跳转.

以下为简单的ThreadFactory 示例

Java源码解析 ThreadPoolExecutor 线程池_第7张图片

上述示例包括线程工厂和任务执行体的定义;

通过newThread方法快速、统一地创建线程任务,强调线程一定要有特定意义的名称,方便出错时回溯.

单线程池:newSingleThreadExecutor()方法创建,五个参数分别是ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue())。含义是池中保持一个线程,最多也只有一个线程,也就是说这个线程池是顺序执行任务的,多余的任务就在队列中排队。

固定线程池:newFixedThreadPool(nThreads)方法创建

池中保持nThreads个线程,最多也只有nThreads个线程,多余的任务也在队列中排队。

Java源码解析 ThreadPoolExecutor 线程池_第8张图片
Java源码解析 ThreadPoolExecutor 线程池_第9张图片
Java源码解析 ThreadPoolExecutor 线程池_第10张图片

线程数固定且线程不超时

缓存线程池:newCachedThreadPool()创建,五个参数分别是ThreadPoolExecutor(0, Integer.MAXVALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue())。 含义是池中不保持固定数量的线程,随需创建,最多可以创建Integer.MAXVALUE个线程(说一句,这个数量已经大大超过目前任何操作系统允许的线程数了),空闲的线程最多保持60秒,多余的任务在SynchronousQueue(所有阻塞、并发队列在后续文章中具体介绍)中等待。

为什么单线程池和固定线程池使用的任务阻塞队列是LinkedBlockingQueue(),而缓存线程池使用的是SynchronousQueue()呢?

因为单线程池和固定线程池中,线程数量是有限的,因此提交的任务需要在LinkedBlockingQueue队列中等待空余的线程;而缓存线程池中,线程数量几乎无限(上限为Integer.MAX_VALUE),因此提交的任务只需要在SynchronousQueue队列中同步移交给空余线程即可。

单线程调度线程池:newSingleThreadScheduledExecutor()创建,五个参数分别是 (1, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue())。含义是池中保持1个线程,多余的任务在DelayedWorkQueue中等待。

固定调度线程池:newScheduledThreadPool(n)创建,五个参数分别是 (n, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue())。含义是池中保持n个线程,多余的任务在DelayedWorkQueue中等待。

有一项技术可以缓解执行时间较长任务造成的影响,即限定任务等待资源的时间,而不要无限的等待

先看第一个例子,测试单线程池、固定线程池和缓存线程池(注意增加和取消注释):

public class ThreadPoolExam {

   public static void main(String[] args) {

       //first test for singleThreadPool

       ExecutorService pool = Executors.newSingleThreadExecutor();

       //second test for fixedThreadPool

//        ExecutorService pool = Executors.newFixedThreadPool(2);

       //third test for cachedThreadPool

//        ExecutorService pool = Executors.newCachedThreadPool();

       for (int i = 0; i < 5; i++) {

           pool.execute(new TaskInPool(i));

       }

       pool.shutdown();

   }

}

class TaskInPool implements Runnable {

   private final int id;

   TaskInPool(int id) {

       this.id = id;

   }

   @Override

   public void run() {

       try {

           for (int i = 0; i < 5; i++) {

               System.out.println("TaskInPool-["+id+"] is running phase-"+i);

               TimeUnit.SECONDS.sleep(1);

           }

           System.out.println("TaskInPool-["+id+"] is over");

       } catch (InterruptedException e) {

           e.printStackTrace();

       }

   }

}

如图为排查底层公共缓存调用出错时的截图

绿色框采用自定义的线程工厂,明显比蓝色框默认的线程工厂创建的线程名称拥有更多的额外信息:如调用来源、线程的业务含义,有助于快速定位到死锁、StackOverflowError 等问题.

Java源码解析 ThreadPoolExecutor 线程池_第11张图片

拒绝策略

下面再简单地实现一下 RejectedExecutionHandler;

实现了接口的 rejectedExecution方法,打印出当前线程池状态

Java源码解析 ThreadPoolExecutor 线程池_第12张图片

在 ThreadPoolExecutor中提供了四个公开的内部静态类● AbortPolicy -默认丢弃任务并抛出RejectedExecutionException

Java源码解析 ThreadPoolExecutor 线程池_第13张图片

● DiscardPolicy -不推荐丢弃任务,但不拋异常.

Java源码解析 ThreadPoolExecutor 线程池_第14张图片

● DiscardOldestPolicy

抛弃队列中等待最久的任务,然后把当前任务加入队列中.

Java源码解析 ThreadPoolExecutor 线程池_第15张图片

● CallerRunsPolicy

调用任务的run()方法绕过线程池直接执行.

Java源码解析 ThreadPoolExecutor 线程池_第16张图片

根据之前实现的线程工厂和拒绝策略,线程池的相关代码实现如下

Java源码解析 ThreadPoolExecutor 线程池_第17张图片

当任务被拒绝的时候,拒绝策略会打印出当前线程池的大小已经达到了 maximumPoolSize=2,且队列已满,完成的任务数提示已经有1个(最后一行).

Java源码解析 ThreadPoolExecutor 线程池_第18张图片

源码讲解

在 ThreadPoolExecutor的属性定义中频繁地用位运算来表示线程池状态;

位运算是改变当前值的一种高效手段.

下面从属性定义开始

Integer 有32位;

最右边29位表工作线程数;

最左边3位表示线程池状态,可表示从0至7的8个不同数值

线程池的状态用高3位表示,其中包括了符号位.

五种状态的十进制值按从小到大依次排序为

RUNNING < SHUTDOWN < STOP < TIDYING

000-1111111111111111111111111; 类似于子网掩码,用于与运算; 得到左边3位,还是右边29位

用左边3位,实现5种线程池状态;

在左3位之后加入中画线有助于理解;

111 - 0000000000000000000000000000(十进制: -536, 870, 912);

该状态表 线程池能接受新任务

000 - 0000000000000000000000000(十进制: 0);

此状态不再接受新任务,但可继续执行队列中的任务

001 - 00000000000000000000000000(十进制: 536,870, 912);

此状态全面拒绝,并中断正在处理的任务

010 - 00000000000000000000000000.(十进制值: 1, 073, 741, 824);

该状态表 所有任务已经被终止

101 - 000000000000000000000000000(十进制值: 1, 610,612, 736)

该状态表 已清理完现场

与运算,比如 001 - 000000000000000000000100011 表 67个工作线程;掩码取反: 111 - 00000000000000000000000.,即得到左边3位001;表示线程池当前处于STOP状态

同理掩码 000 - 11111111111111111111,得到右边29位,即工作线程数

把左3位与右29位或运算,合并成一个值

我们都知道 Executor接口有且只有一个方法 execute();

通过参数传入待执行线程的对象.

下面分析 ThreadPoolExecutor关于 execute()方法的实现

线程池执行任务的方法如下

  /**

    * Executes the given task sometime in the future.  The task

    * may execute in a new thread or in an existing pooled thread.

    *

    * If the task cannot be submitted for execution, either because this

    * executor has been shutdown or because its capacity has been reached,

    * the task is handled by the current {@code RejectedExecutionHandler}.

    *

    * @param command the task to execute

    * @throws RejectedExecutionException at discretion of

    *         {@code RejectedExecutionHandler}, if the task

    *         cannot be accepted for execution

    * @throws NullPointerException if {@code command} is null

    */

   public void execute(Runnable command) {

       if (command == null)

           throw new NullPointerException();

       /*

        * Proceed in 3 steps:

        *

        * 1. If fewer than corePoolSize threads are running, try to

        * start a new thread with the given command as its first

        * task.  The call to addWorker atomically checks runState and

        * workerCount, and so prevents false alarms that would add

        * threads when it shouldn't, by returning false.

        *

        * 2. If a task can be successfully queued, then we still need

        * to double-check whether we should have added a thread

        * (because existing ones died since last checking) or that

        * the pool shut down since entry into this method. So we

        * recheck state and if necessary roll back the enqueuing if

        * stopped, or start a new thread if there are none.

        *

        * 3. If we cannot queue task, then we try to add a new

        * thread.  If it fails, we know we are shut down or saturated

        * and so reject the task.

        */

       // 返回包含线程数及线程池状态的Integer 类型数值

       int c = ctl.get();

       // 若工作线程数 < 核心线程数,则创建线程并执行当前任务

       if (workerCountOf(c) < corePoolSize) {

           if (addWorker(command, true))

execute方法在不同的阶段有三次 addWorker的尝试动作。

               return;

           // 若创建失败,为防止外部已经在线程池中加入新任务,在此重新获取一下

           c = ctl.get();

       }

       // 若 工作线程数 >=核心线程数 或线程创建失败,则将当前任务放到工作队列中

       // 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列

       if (isRunning(c) && workQueue.offer(command)) {

           int recheck = ctl.get();

           // 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列

           if (! isRunning(recheck) && remove(command))

               reject(command);

           // 若之前的线程已被消费完,新建一个线程

           else if (workerCountOf(recheck) == 0)

               addWorker(null, false);

       // 核心线程和队列都已满,尝试创建一个新线程

       }

       else if (!addWorker(command, false))

           // 抛出RejectedExecutionException异常

           // 若 addWorker 返回是 false,即创建失败,则唤醒拒绝策略.

           reject(command);

   }

发生拒绝的理由有两个

( 1 )线程池状态为非RUNNING状态

(2)等待队列已满。

下面继续分析 addWorker

addWorker 源码解析

根据当前线程池状态,检查是否可以添加新的任务线程,若可以则创建并启动任务;

若一切正常则返回true;

返回false的可能性如下

线程池没有处于RUNNING态

线程工厂创建新的任务线程失败

参数

firstTask 外部启动线程池时需要构造的第一个线程,它是线程的母体

core 新增工作线程时的判断指标

true 需要判断当前 RUNNING态的线程是否少于 corePoolsize

false 需要判断当前 RUNNING态的线程是否少于 maximumPoolsize 

Java源码解析 ThreadPoolExecutor 线程池_第19张图片
Java源码解析 ThreadPoolExecutor 线程池_第20张图片
Java源码解析 ThreadPoolExecutor 线程池_第21张图片

这段代码晦涩难懂,部分地方甚至违反代码规约,但其中蕴含丰富的编码知识点

第1处,配合循环语句出现的label,类似于goto 作用

label 定义时,必须把标签和冒号的组合语句紧紧相邻定义在循环体之前,否则会编译出错.

目的是 在实现多重循环时能够快速退出到任何一层;

出发点似乎非常贴心,但在大型软件项目中,滥用标签行跳转的后果将是灾难性的.

示例代码中在 retry下方有两个无限循环;

在 workerCount加1成功后,直接退出两层循环.

第2处,这样的表达式不利于阅读,应如是

Java源码解析 ThreadPoolExecutor 线程池_第22张图片

第3处,与第1处的标签呼应, AtomicInteger对象的加1操作是原子性的; breakretry表 直接跳出与 retry 相邻的这个循环体

第4处,此 continue跳转至标签处,继续执行循环.

如果条件为false,则说明线程池还处于运行状态,即继续在 for(;)循环内执行.

第5处, compareAndIncrementWorkerCount方法执行失败的概率非常低.

即使失败,再次执行时成功的概率也是极高的,类似于自旋原理.

这里是先加1,创建失败再减1,这是轻量处理并发创建线程的方式;

如果先创建线程,成功再加1,当发现超出限制后再销毁线程,那么这样的处理方式明显比前者代价要大.

第6处, Worker对象是工作线程的核心类实现,部分源码如下

它实现了 Runnable接口,并把本对象作为参数输入给 run()中的 runWorker(this);

Java源码解析 ThreadPoolExecutor 线程池_第23张图片

所以内部属性线程 thread在 start的时候,即会调用 runWorker.

总结

线程池的相关源码比较精炼,还包括线程池的销毁、任务提取和消费等,与线程状态图一样,线程池也有自己独立的状态转化流程,本节不再展开。

总结一下,使用线程池要注意如下几点:

(1)合理设置各类参数,应根据实际业务场景来设置合理的工作线程数。

(2)线程资源必须通过线程池提供,不允许在应用中自行显式创建线程。

(3)创建线程或线程池时请指定有意义的线程名称,方便出错时回溯。

线程池不允许使用Executors,而是通过ThreadPoolExecutor的方式创建,这样的处理方式能更加明确线程池的运行规则,规避资源耗尽的风险。

进一步查看源码发现,这些方法最终都调用了ThreadPoolExecutor和ScheduledThreadPoolExecutor的构造函数

而ScheduledThreadPoolExecutor继承自ThreadPoolExecutor

0.2 ThreadPoolExecutor 自定义线程池

它们都是某种线程池,可以控制线程创建,释放,并通过某种策略尝试复用线程去执行任务的一个管理框架

Java源码解析 ThreadPoolExecutor 线程池_第24张图片

,因此最终所有线程池的构造函数都调用了Java5后推出的ThreadPoolExecutor的如下构造函数

Java源码解析 ThreadPoolExecutor 线程池_第25张图片

Java默认提供的线程池

Java中的线程池是运用场景最多的并发框架,几乎所有需要异步或并发执行任务的程序都可以使用线程池

Java源码解析 ThreadPoolExecutor 线程池_第26张图片
Java源码解析 ThreadPoolExecutor 线程池_第27张图片

我们只需要将待执行的方法放入 run 方法中,将 Runnable 接口的实现类交给线程池的

execute 方法,作为他的一个参数,比如:

Executor e=Executors.newSingleThreadExecutor();          

e.execute(new Runnable(){ //匿名内部类     public  void run(){  

//需要执行的任务

}

});

线程池的实现原理

Java源码解析 ThreadPoolExecutor 线程池_第28张图片

ThreadPoolExecutor执行execute()分4种情况

若当前运行的线程少于corePoolSize,则创建新线程来执行任务(执行这一步需要获取全局锁)

若运行的线程多于或等于corePoolSize,则将任务加入BlockingQueue

若无法将任务加入BlockingQueue,则创建新的线程来处理任务(执行这一步需要获取全局锁)

若创建新线程将使当前运行的线程超出maximumPoolSize,任务将被拒绝,并调用RejectedExecutionHandler.rejectedExecution()

采取上述思路,是为了在执行 execute()时,尽可能避免获取全局锁

在ThreadPoolExecutor完成预热之后(当前运行的线程数大于等于corePoolSize),几乎所有的execute()方法调用都是执行步骤2,而步骤2不需要获取全局锁

源码分析

  /**

    * 检查是否可以根据当前池状态和给定的边界(核心或最大)

    * 添加新工作线程。如果是这样,工作线程数量会相应调整,如果可能的话,一个新的工作线程创建并启动

    * 将firstTask作为其运行的第一项任务。

    * 如果池已停止此方法返回false

    * 如果线程工厂在被访问时未能创建线程,也返回false

    * 如果线程创建失败,或者是由于线程工厂返回null,或者由于异常(通常是在调用Thread.start()后的OOM)),我们干净地回滚。

    *

    * @param core if true use corePoolSize as bound, else

    * maximumPoolSize. (A boolean indicator is used here rather than a

    * value to ensure reads of fresh values after checking other pool

    * state).

    * @return true if successful

    */

   private boolean addWorker(Runnable firstTask, boolean core) {

       retry:

       for (;;) {

           int c = ctl.get();

           int rs = runStateOf(c);

   /**

    * Check if queue empty only if necessary.

    *

    * 如果线程池已关闭,并满足以下条件之一,那么不创建新的 worker:

    *      1. 线程池状态大于 SHUTDOWN,也就是 STOP, TIDYING, 或 TERMINATED

    *      2. firstTask != null

    *      3. workQueue.isEmpty()

    * 简单分析下:

    *      状态控制的问题,当线程池处于 SHUTDOWN ,不允许提交任务,但是已有任务继续执行

    *      当状态大于 SHUTDOWN ,不允许提交任务,且中断正在执行任务

    *      多说一句:若线程池处于 SHUTDOWN,但 firstTask 为 null,且 workQueue 非空,是允许创建 worker 的

    *  

    */

           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;

               // 由于有并发,重新再读取一下 ctl

               c = ctl.get();  // Re-read ctl

               // 正常如果是 CAS 失败的话,进到下一个里层的for循环就可以了

               // 可如果是因为其他线程的操作,导致线程池的状态发生了变更,如有其他线程关闭了这个线程池

               // 那么需要回到外层的for循环

               if (runStateOf(c) != rs)

                   continue retry;

               // else CAS failed due to workerCount change; retry inner loop

           }

       }

    /* *

       * 到这里,我们认为在当前这个时刻,可以开始创建线程来执行任务

       */

       // worker 是否已经启动

       boolean workerStarted = false;

       // 是否已将这个 worker 添加到 workers 这个 HashSet 中

       boolean workerAdded = false;

       Worker w = null;

       try {

          // 把 firstTask 传给 worker 的构造方法

           w = new Worker(firstTask);

           // 取 worker 中的线程对象,Worker的构造方法会调用 ThreadFactory 来创建一个新的线程

           final Thread t = w.thread;

           if (t != null) {

              //先加锁

               final ReentrantLock mainLock = this.mainLock;

               // 这个是整个类的全局锁,持有这个锁才能让下面的操作“顺理成章”,

               // 因为关闭一个线程池需要这个锁,至少我持有锁的期间,线程池不会被关闭

               mainLock.lock();

               try {

                   // Recheck while holding lock.

                   // Back out on ThreadFactory failure or if

                   // shut down before lock acquired.

                   int rs = runStateOf(ctl.get());

                   // 小于 SHUTTDOWN 即 RUNNING

                   // 如果等于 SHUTDOWN,不接受新的任务,但是会继续执行等待队列中的任务

                   if (rs < SHUTDOWN ||

                       (rs == SHUTDOWN && firstTask == null)) {

                       // worker 里面的 thread 不能是已启动的

                       if (t.isAlive()) // precheck that t is startable

                           throw new IllegalThreadStateException();

                       // 加到 workers 这个 HashSet 中

                       workers.add(w);

                       int s = workers.size();

                       if (s > largestPoolSize)

                           largestPoolSize = s;

                       workerAdded = true;

                   }

               } finally {

                   mainLock.unlock();

               }

              // 若添加成功

               if (workerAdded) {

                   // 启动线程

                   t.start();

                   workerStarted = true;

               }

           }

       } finally {

           // 若线程没有启动,做一些清理工作,若前面 workCount 加了 1,将其减掉

           if (! workerStarted)

               addWorkerFailed(w);

       }

       // 返回线程是否启动成功

       return workerStarted;

   }

看下 addWorkFailed !workers 中删除掉相应的 worker,workCount 减 1

private void addWor

Java源码解析 ThreadPoolExecutor 线程池_第29张图片

worker 中的线程 start 后,其 run 方法会调用 runWorker

继续往下看 runWorker

Java源码解析 ThreadPoolExecutor 线程池_第30张图片

//  worker 线程启动后调用,while 循环(即自旋!)不断从等待队列获取任务并执行

//  worker 初始化时,可指定 firstTask,那么第一个任务也就可以不需要从队列中获取

final void runWorker(Worker w) {

   Thread wt = Thread.currentThread();

   // 该线程的第一个任务(若有)

   Runnable task = w.firstTask;

   w.firstTask = null;

   // 允许中断

   w.unlock();

   boolean completedAbruptly = true;

   try {

       // 循环调用 getTask 获取任务

       while (task != null || (task = getTask()) != null) {

           w.lock();          

           // 若线程池状态大于等于 STOP,那么意味着该线程也要中断

             /**

              * 若线程池STOP,请确保线程 已被中断

              * 如果没有,请确保线程未被中断

              * 这需要在第二种情况下进行重新检查,以便在关中断时处理shutdownNow竞争

              */

           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) {

                   // 这里不允许抛出 Throwable,所以转换为 Error

                   thrown = x; throw new Error(x);

               } finally {

                   // 也是一个钩子方法,将 task 和异常作为参数,留给需要的子类实现




小编整理了一些java进阶学习资料和面试题,需要资料的请加JAVA高阶学习Q群:664389243 这是小编创建的java高阶学习交流群,加群一起交流学习深造。群里也有小编整理的2019年最新最全的java高阶学习资料!

你可能感兴趣的:(Java源码解析 ThreadPoolExecutor 线程池)