派生体系
java.util.concurrent
  ThreadPoolExecutor
    AbstractExecutorService
      ExecutorService
        Executor
 
这个类是Executor框的核心实现,它的名字向我们表明,它是使用thread pool实现的。这个thread pool主要解决了两个问题:
  1. 执行大量的单个异步任务,一般情况下,它能提升整体的性能。
  2. 执行由多个任务组成的任务集合,通过Future列表返回每个任务的执行结果。
 
设计原理

 
重要概念
为了能够在更多上下文环境中使用,ThreadPool定义了一些概念,这些概念都直接或间接对应着可调节参数,如果不了解这些概念含义,很难正确地使用这些参数。下面来看一下这些概念及其含义:
 
当前,核心,最小,最大线程数(poolSize, corePoolSize, minimumPoolSize, maximumPoolSize)
poolSize: 当前处于运行和空闲状态的总线程数。
corePoolSize: 核心线程数, 当poolSize<=corePoolSize时,存在的线程称为coreThread。
minimumPoolSize: 最小线程数,当minimumPoolsize = allowCoreThreadTimeOut ? 0 : corePoolSize ,
maximunPoolSize: 最大线程数。
ThreadPool在运行过程中会自动的调节线程数量(poolSize), 一般来说,poolSize处于[corePoolSize maximumPoolSize]区间之内。
当用户调用execute提交一个任务时,如果poolSize<corePoolSize, 会创建一个新线程处理这个任务。如果如果poolSize处于[corePoolSize maximumPoolSize]区间内,只有队列满是才会创建新线程。无论如何,poolSize不会大于maximumPoolSize。
默认情况下,ThreadPool没有收到任何任务时pooSize = 0, 只有当ThreadPool开始收到任务之后才会创建线程。但是可以通过覆盖prestartCoreThread或prestartAllCoreThreads方法改变这种行为,提前创建线程。
 
线程工厂--ThreadFactory
ThreadPool使用实现了ThreadFactory接口的实现创建新线程。Executors工厂类提供了defaultThreadFactory方法,该方法返回一个默认的ThreadFactory实例。使用这个实例创建的线程具有相同的优先级,是非后台线程,命名上使用相同的前缀。如果不满意这这些行为,可以自己实现一个ThreadFactory交给ThreadPool使用。
 
保持存活时间(keepAliveTime)
如果poolSize > corePoolSize, 当一个线程的空闲时间大于keepAliveTime, 它会被终止掉。默认情况下当poolSize <= corePoolSize时,keepAliveTime不会有影响,如果调用 allowCoreThreadTimeOut(true), 可以让keepAliveTime在这个时间也起作用。
 
任务排队(queuing)
任何BlockingQueue的实例都可以用于保存排队的任务。不同的BlockingQueue实现决定了不同的排队策略:
SynchronousQueue: 同步队列,当提交一个任务时,要求ThreadPool中当前有至少一个空闲线程,或者可以创建新的线程(poolSize < maximumPoolSize)立即执行这个任务,否则ThreadPool会拒绝这个任务。
LinkedBlockingQueue: 无限制的队列(只受限于能够使用的内存), 不会处于full状态, offer方法不会返回false,这意味这ThreadPool的pooSize<=corePoolSize, 不会创建大于corePoolSize的线程数。
ArrayBlockingQueue: 有限制的队列, 受限于它的capacity。当poolSize == corePoolSize且队列没满时, 新提交的任务会追加到队列中排队执行。 当poolSize在[corePoolSize maximumPooSize)区间同时队被填列满时,将会创建新的线程。直到poolSize == maximumPoolSize位置。 如果队列被填满同时pooSize == maximumPoolSize,新的任务会被拒绝。
 
拒绝任务(rejected tasks)
当ThreadPool遇到以下两种情况时会触发拒绝任务策略:
  1. 正常情况下BlockingQueue被填满,同时poolSize == maximumPoolSize。
  2. 被关闭
ThreadPool使用RejectedExecutionHandler处理丢弃动作,默认定义了4中丢弃策略:
ThreadPoolExecutor.AbortPolicy: 抛出RejectedExecutionException异常。
ThreadPoolExecutor.CallerRunsPolicy: 自己执行这个被抛弃的任务。
ThreadPoolExecutor.DiscardPolicy: 悄无声息的丢弃掉这人任务。
 
状态
ThreadPool定义了5状态
RUNNING: 接受新提交的任务,执行队列中发任务。
SHUTDOWN: 不接受新提交的任务,但仍然会执行队列中的人。
STOP: 不接受新提交的任务,不执行队列中的任务,而且会打断正在执行中的任务。
TIDYING: 所有的任务都终止了,并且线程数为0,当所有的线程都过渡到TIDYING状态后会调用treminated方法。
TERMINATED: treminated方法调用已经完成。
 
状态之间的转换关系
RUNNING --> SHUTDOWN
调用shutdown()
(RUNNING或SHUTDOWN) -- > STOP
调用shutdownNow()
SHUTDOWN --> TIDYING
队列为空,同时线程数为0
TIDYING --> TREMINATED
treminated()执行完成。
 
向ThreadPool提交任务: execute
 
ThreadPoolExecutor实例创建之后,在没有调用execute提交任务之前,ThreadPool中是没有线程的,线程的创建是依赖exeute来驱动的。可以说,exeute是ThreadPoolExecutor运行的触发器,所有我选择先从exeute方法开始分析代码。
public void execute(Runnable command) {
  if (command == null)
    throw new NullPointerException();
  int c = ctl.get();
  if (workerCountOf(c) < corePoolSize) { //如果线程数小于 corePoolSize, 创建一个新线程。
    if (addWorker(command, true))
     return;
    c = ctl.get();
  }
  if (isRunning(c) && workQueue.offer(command)) { //如果处于RUNNGIN状态把任务放到队列中
    int recheck = ctl.get();
    if (! isRunning(recheck) && remove(command)) //再次检查线程状态,如果不是RUNNING状态,把任务从队列删除,然后拒绝这个任务
      reject(command);
    else if (workerCountOf(recheck) == 0) //如果线程数为0,创建一个新线程
      addWorker(null, false);
  }
  /*如果运行到这里说明当前不是出于RUNNING状态,或处于RUNNING状态但队列已经被填满
  *尝试创建新的线程执行这个任务,如果失败,拒绝这任务
  */
  else if (!addWorker(command, false))
    reject(command);
}
以上就是exeute代码,它很简单,但其中ctl成员变量比较费解。ctl是AtomicInteger类型,它被用来打包保存ThreadPoolExecutor的状态和线程数。
AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
它初始化时,把状态设置成RUNNING,下面来看看它的结构
 
高位 ---- > 低位
运算状态(run state)
线程数(workerCount)
31 -- 29
28 -- 0
状态位
RUNNING
1
1
1
 
SHUTDOWN
 
0
0
0
 
STOP
0
0
1
 
TIDYING
0
1
0
 
TREMINATED
0
1
1
 
知道了这些数据的保存方式,把他们取出来,只需要一些简单的位运算就可以了。
状态的大小关系 RUNNING < SHUTDOWN < STOP < TIDYING < TREMINATED,
runStateOf(clt.get()) < SHUTDOWN RUNNING状态
runStateOf(clt.get()) >= SHUTDOWN 非RUNNING状态
这个大小关系要记住,这样理解代码会更快。
 
创建新线程
ThreadPool把线程封装成Worker对对象,添加worker就是添加线程,addWorker方法做的事情就是添加线程。
private boolean addWorker(Runnable firstTask, boolean core) {
    /*这段代码的作用是确保满足一下条件的任意一个时才创建新线程
   *1.  处于RUNNING 状态, 可以接受新任务,可以继续执行队列中的任务
   *2. 处于SHUTDOWN状态,  队列不是空,且当前没有提交新任务
   */
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
 
        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&   //非RUNNINGG状态
            ! (rs == SHUTDOWN &&  
               firstTask == null &&  //当前提交的新任务
               ! workQueue.isEmpty())) // 队列不是空
            return false;
 
        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize)) //如果当前调用创建的是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
        }
    }
    //执行到这里表示已经通过检查可以创建新线程,并且线程数已经加1
    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 {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int rs = runStateOf(ctl.get());
 
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {  //再次检查,确保当前仍然满足允许创建线程的条件
                    if (t.isAlive()) // 确保Thread还没有调用start()
                        throw new IllegalThreadStateException();
                    workers.add(w); //把worker线程放进HashSet中
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                t.start();  //启动新线程
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}
 
线程的主循环
Worker实现了Runnable接口
private final class Worker extends AbstractQueuedSynchronizer  implements Runnable
构造方法
Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
}
创建线程时把Worker实例本身当做线程的Runnable产生,所以当线程启动后,将会调用Worker的run方法。
public void run() {
        runWorker(this);
}
线程的主循环就在runWorker方法中实现
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;  //如果firstTask!=null, 先执行firstTask
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) { //如果没有firstTask,  从队列中取出一个task, 如果没有取到,退出线程
            w.lock();
        //如果处于状态>=STOP(前面已经讲过状态直接的大小关系), 确保线程处于interrupted状态
       //否则清除线程的interrupted状态
            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; //把当前task置空,这样才能调用getTask从队列里取出任务
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
       //正常退出线程 completedAbruptly是true, 异常导致的线程退出为false
        processWorkerExit(w, completedAbruptly);
    }
}
 
从队列中得到排队的任务
在runWorker主循环中,除了第一次的任务从worker的firsTask(在它不是null的情况下)取之外, 后面每次都是调用getTask从队列中取出一个任务。
下面是getTask的代码分析
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
 
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c); //得到当前状态
 
        // 如果当前状态 > SHUTDOWN 退出线程
    // 如果当前状态 == SHUTDOWN 且 队列为空,退出线程
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();  //减少当前线程数
            return null;
        }
 
        int wc = workerCountOf(c); //得到当前的线程数
 
        //线程是否允许超时的条件: 设置允许coreThread超时,或者当前线程数 > corePoolSize
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
    
    //线程退出需要同时满足以下两个条件条件: 
    //1. 当前线程数>maximumPooSize 或 允许超时同时检查到已经超时
    //2. 当前线程数>1 或 队列为空
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c)) //减少当前线程数, 这个方法确保多线程环境下不会过多地结束线程。
                return null;
            continue;
        }
 
        try {
           //取出一个任务。如果允许超时,调用poll,否则调用take
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true; //已经超时,运行到这里表明poll超时返回
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}
getTask的功能除了取出一个任务以外,它还负责在条件满足的情况下正常地结束一个线程
 
线程结束
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // 如果线程是由于异常原因结束的,这里要纠正线程数
        decrementWorkerCount();
 
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);  //把线程从HashSet中删除
    } finally {
        mainLock.unlock();
    }
 
    tryTerminate(); //尝试终止整个ThreadPool
 
    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {  //如果当前状态<STOP
        if (!completedAbruptly) { //如果不是异常结束
             //计算最小线程数min
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty()) 
                min = 1;
            if (workerCountOf(c) >= min)  //如果当前线程数>=min直接返回
                return; // replacement not needed
        }
        //创建新线程, 条件:
        //当前线程正常结束
        //当前线程异常结束,但当前线程数小于最小线程数
        addWorker(null, false);
    }
}
 
上面的代码实现了线程的生命周期的管理,线程只有在ThreadPoolExecutor的状态处于RUNNGIN或SHUTDOWN时才可以存在。下面是这两种状态下线程的生存状态:
RUNNING:
    允许coreThread超时: 线程空闲(意味着队列为空)时间超过 keepAliveTime, 线程会被结束, 直到线程数为0。
    不允许coreThread超时:  线程空闲时间超过 keepAliveTime, 线程会被结束,直到线程数为corePoolSize。
SHUDOWN:
      当线程把已经在队列里的所有任务执行完毕后,所有线程都会进入退出流程,最终退出。
 
整个ThreadPoolExecutor的状态变迁
前面已经讲过,ThreadPool的状态和线程数被打包方进一个32整数中:
AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
初始化把状态设置成RUNNING, 线程为0
调用shutdown时把状态从RUNNING置为SHUTDOWN,  随后过渡到TIDYING->TREMINATED。
当调用shutdownNow时把状态从(RUNNING 或 SHUTDOWN) 设置为STOP,  随后过渡到TIDYING->TREMINATED。
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN);    //只有当前状态<SHUTDOWN时才执行状态设置的动作
        interruptIdleWorkers();  //打断所有空闲的的线程,让这些线程有机会自己结束
        onShutdown(); // 回调方法,默认什么都没做,子类可以覆盖
    } finally {
        mainLock.unlock();
    }
    tryTerminate(); //尝试执行ThreadPool的结束操作
}
shutdownNow和shutdown的操作大致一样,不同的是它把状态设置成STOP,还会返回队列中没有来得及执行的任务list。
tryTerminate方法作用是尝试结束整个ThreadPool, 它不一定会执行真正的结束动作。它在三个地方被调用, worker线程结束时,shudown中,shutdownNow中。
final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
    //满足以下三个条件中的任何一个就立即返回
    //1. 处于RUNNGING状态
    //2. 状态>= TIDYING
    //3. 处于SHUTDOWN状态,且队列不是空
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
    //如果处于STOP状态,且线程数不为0,通知一个处于空闲的线程结束自己
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }
    //执行到这里表示目前状态>=SHUTDOWN,线程数已经是0
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { //总有一个线程会运行到这里,把状态置为 TIDYING
                try {
                    terminated(); //调用回调方面,默认什么都没干,子类可以覆盖
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0));  //把状态置为TREMINATED, 自此整个ThreadPool才算终结
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}
tryTerminate之所以要在三个地方调用,是为了保证当调用shutdown或shutdownNow之后,总有一个线程会完成最后的终结工作。
 
参数设置
分析完前面代码后,再来使用它,它的参数怎么设置自然就了然于心。
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) 
public void allowCoreThreadTimeOut(boolean value)
public void setCorePoolSize(int corePoolSize) 
public void setKeepAliveTime(long time, TimeUnit unit)
public void setMaximumPoolSize(int maximumPoolSize)
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) 
public void setThreadFactory(ThreadFactory threadFactory)

ThreadPoolExecutor代码解析的更多相关文章

  1. VBA常用代码解析

    031 删除工作表中的空行 如果需要删除工作表中所有的空行,可以使用下面的代码. Sub DelBlankRow() DimrRow As Long DimLRow As Long Dimi As L ...

  2. [nRF51822] 12、基础实验代码解析大全 · 实验19 - PWM

    一.PWM概述: PWM(Pulse Width Modulation):脉冲宽度调制技术,通过对一系列脉冲的宽度进行调制,来等效地获得所需要波形. PWM 的几个基本概念: 1) 占空比:占空比是指 ...

  3. [nRF51822] 11、基础实验代码解析大全 · 实验16 - 内部FLASH读写

     一.实验内容: 通过串口发送单个字符到NRF51822,NRF51822 接收到字符后将其写入到FLASH 的最后一页,之后将其读出并通过串口打印出数据. 二.nRF51822芯片内部flash知识 ...

  4. [nRF51822] 10、基础实验代码解析大全 · 实验15 - RTC

    一.实验内容: 配置NRF51822 的RTC0 的TICK 频率为8Hz,COMPARE0 匹配事件触发周期为3 秒,并使能了TICK 和COMPARE0 中断. TICK 中断中驱动指示灯D1 翻 ...

  5. [nRF51822] 9、基础实验代码解析大全 · 实验12 - ADC

    一.本实验ADC 配置 分辨率:10 位. 输入通道:5,即使用输入通道AIN5 检测电位器的电压. ADC 基准电压:1.2V. 二.NRF51822 ADC 管脚分布 NRF51822 的ADC ...

  6. java集合框架之java HashMap代码解析

     java集合框架之java HashMap代码解析 文章Java集合框架综述后,具体集合类的代码,首先以既熟悉又陌生的HashMap开始. 源自http://www.codeceo.com/arti ...

  7. Kakfa揭秘 Day8 DirectKafkaStream代码解析

    Kakfa揭秘 Day8 DirectKafkaStream代码解析 今天让我们进入SparkStreaming,看一下其中重要的Kafka模块DirectStream的具体实现. 构造Stream ...

  8. linux内存管理--slab及其代码解析

    Linux内核使用了源自于 Solaris 的一种方法,但是这种方法在嵌入式系统中已经使用了很长时间了,它是将内存作为对象按照大小进行分配,被称为slab高速缓存. 内存管理的目标是提供一种方法,为实 ...

  9. MYSQL常见出错mysql_errno()代码解析

    如题,今天遇到怎么一个问题, 在理论上代码是不会有问题的,但是还是报了如上的错误,把sql打印出來放到DB中却可以正常执行.真是郁闷,在百度里面 渡 了很久没有相关的解释,到时找到几个没有人回复的 & ...

随机推荐

  1. Spring MVC 的国际化和本地化

    国际化: i18n 本地化: l10n java.util.Locale 类表示一个语言区域.一个 Locale 对象包含 3 个主要元件:language.country.variant java. ...

  2. 20165213周启航java学习总结

    20165213周启航java学习总结 一.每周博客链接及二维码 预备作业一:我所期望的师生关系:http://www.cnblogs.com/rocedu/p/6255835.html#WEEK15 ...

  3. ActiveMQ_5死信队列

    activemq死信队列 DLQ-死信队列(Dead Letter Queue)用来保存处理失败或者过期的消息. 出现以下情况时,消息会被redelivered: A transacted sessi ...

  4. 1.html基础标签:文本+链接+图片

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  5. Java学习笔记30(集合框架四:List接口)

    List接口继承自Collection接口 具有重要的三大特点: 1.有序集合:存入和取出的顺序一致 2.此接口的用户可以对列表中每个元素插入位置精确的控制:可以通过索引操作 3.可以存储重复元素 L ...

  6. Shell - 简明Shell入门14 - 操作符(Operator)

    示例脚本及注释 #!/bin/bash echo "No code, just some comments." # ### 通配符 # * 代表任意(0个或多个)字符 # ? 代表 ...

  7. 干货:教你如何监控 Java 线程池运行状态

    之前写过一篇 Java 线程池的使用介绍文章<线程池全面解析>,全面介绍了什么是线程池.线程池核心类.线程池工作流程.线程池分类.拒绝策略.及如何提交与关闭线程池等. 但在实际开发过程中, ...

  8. mint-ui Infinite scroll 重复加载、加载无效的原因及解决方案

    1.无限滚动的运用场景: 一般运用在列表展示,有分页.下拉加载更多的需求中. 2.代码分析 代码很简单,实现了列表分页,数据加载完之后显示数据状态 <template> <div c ...

  9. PCA历程详细python代码(原创)

    #PCA主成分分析,原文为文末的链接,代码为自己亲自手码 def cov_out1(dx,dy): #第一步:求解x,y各自的均值 mean_x=0 mean_y=0 for i in range(l ...

  10. C# 线程中使用delegate对控件进行操作

    如果在线程中想改变控件的值是不可以的,会报出以下错误. 那么,如何在线程中改变控件上的值呢?第一个想到的就是委托. 委托定义:委托是一个类,它定义了方法的类型,使得可以将方法当作另一个方法的参数来进行 ...