# 说说ThreadPoolExecutor

## 认识
先来看看它所在的架构体系:
```java
package java.util.concurrent;
public interface Executor { void execute(Runnable command); }
public interface ExecutorService extends Executor {
//新加一些方法
}
public abstract class AbstractExecutorService implements ExecutorService {
//新加一些方法,以及一些方法的基本实现
}
public class ThreadPoolExecutor extends AbstractExecutorService {
//新加一些方法,以及继承方法的实现
}
```
- `Executor`接口就一个方法,用来执行Runnable。官方的说法是,将 `任务的执行` 与 `线程` 解耦和。
- `ExecutorService`接口,继承了`Executor`,同时添加了一些管理任务的方法,如submit/invokeAll/invokeAny/shutdown/shutdownNow 等。
- `AbstractExecutorService`抽象类,实现了`ExecutorService`,提供了默认的一些实现,并添加了三个工具方法。见下图:
- ![AbstractExecutorService.jpg](img/AbstractExecutorService.jpg)
-
- `ThreadPoolExecutor`类,直接可用的类,相对来说很复杂,也是本文的重点。
## 构造
先从构造方法入手。
![ThreadPoolExecutorConstructor.jpg](img/ThreadPoolExecutorConstructor.jpg)

由上图可见,有4个构造方法,大同小异。具体如下:
```java
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
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`: 注意,这是核心线程池的尺寸,但并不是初始化时线程数。当提交的任务数量少于这个数值时,不会经过`workQueue`中转,直接创建新线程来执行。如果线程数量多于这个数值,且线程空闲(任务执行完毕)达到指定时间(keepAliveTime),则会干掉多出来的线程。 -- **需要结合下面的参来理解**
- `maximumPoolSize`: 这个很好理解,就是`线程池`所能提供的最大线程数量。
- `keepAliveTime`: 线程空闲时的存活时间 - 参考`corePoolSize`。
- `unit`: 存活时间的时间单位。
- `workQueue`: 工作队列 - 其实是任务队列。注意,可以使用有界队列,如ArrayBlockingQueue,也可以使用无界队列,如LinkedBlockingQueue。区别在于,能够接收有限/无限的任务。
- `threadFactory`: 线程工厂,提供线程用的。注意,不一定负责线程的管理,仅负责提供线程!线程的管理可能是ExecutorService负责的。
- `handler`: 任务被拒绝(执行或者提交)时的处理器。
## 怎么使用?
实际上,我们很少直接使用这个类,更多的时候是使用`Executors`这个工厂类的`#newFixedThreadPool(int nThreads)`,源码如下:
```java
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
```
对比前面的构造参数,很容易理解。
1. `corePoolSize`和`maximumPoolSize`相同 - 所以线程数量是一定的(当然开始的时候肯定不是,从0开始,见前面`corePoolSize`的说明部分)。
2. `keepAliveTime`是 **0**,所以没有等待时间(实际上这个参数用不到,因为最后的线程数量是一定的 - 如果都使用了)。
3. `workQueue`是`new LinkedBlockingQueue<Runnable>()`,所以这是无界队列,可以接收任意多任务。
这样使用的话,`threadFactory`和`handler`都是默认的,前者是 `Executors.defaultThreadFactory()`,看源码仅是在创建线程的时候添加了"线程组"、"线程名";后者是 `ThreadPoolExecutor.defaultHandler` 。源码如下:
```java
//Executors.defaultThreadFactory() {return new DefaultThreadFactory();}
static class DefaultThreadFactory implements ThreadFactory {
// ...

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;
}
// ...
}

//ThreadPoolExecutor.defaultHandler
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); //什么都不做,直接抛出异常!
```
## 验证
我们来验证下:
1. `corePoolSize`和`workQueue`的关系 - 也就是前面提到的“当提交的任务数量少于`corePoolSize`时,直接开启新线程,不经过`workQueue`”。
2. 当任务无法提交或执行时,直接抛出异常!
```java
@Test
public void testRejectionHandler(){
int corePoolSize = 2; //提交任务时,如果线程数低于2,则创建新线程。完成后则会始终维持最少2个线程。
int maximumPoolSize = 5; //线程池最多允许5个线程存在。-和workQueue什么关系呢?
long keepAliveTime = 5; // 线程数量超过corePoolSize时,如果空闲了,那会空闲多久。
TimeUnit timeUnit = TimeUnit.SECONDS;

// TODO 注意,ArrayBlockingQueue是有界队列,还可以用LinkedBlockingQueue 无界队列 - 就是可以submit无限任务!
ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);//TODO 该队列仅hold由execute方法提交的Runnable tasks。submit会调用execute!
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, timeUnit, workQueue);
Runnable runnable = () -> {
System.out.println(Thread.currentThread().getName());
try{
Thread.sleep(1000L * 1000); //任务一直进行,这样线程就一直不释放
} catch(InterruptedException e){
e.printStackTrace();
}
};
try{
for(int i = 0; i < 10; i++){ //提交10个任务
System.out.println(i);
Future<?> submit = threadPoolExecutor.submit(runnable);
//submit后,Queue里可能有内容,也可能没有 - 可能已经移交给worker线程了!
//FIXME 下面队列用法不对。因为 只有在线程数少于corePoolSize时,才不走队列。
BlockingQueue<Runnable> queue = threadPoolExecutor.getQueue();
System.out.println("queue size: " + queue.size());
System.out.println("queue.remainingCapacity: " + queue.remainingCapacity()); // 这个可能有用
// queue.take();//wait until
System.out.println("queue.peek: " + queue.peek());//奇怪,总是同一个,难道需要同步?
// queue.poll();//retrive and remove head
}
System.out.println("----a");
threadPoolExecutor.execute(runnable); //嗯?什么时候用这个比较好?
System.out.println("----b");
} catch(Exception e){
System.out.println(threadPoolExecutor.isShutdown());
System.out.println(threadPoolExecutor.isTerminated());
System.out.println(threadPoolExecutor.isTerminating());
while(true){
try{
System.out.println(threadPoolExecutor.getQueue().take());
} catch(InterruptedException e1){
e1.printStackTrace();
}
}
}
try{
threadPoolExecutor.awaitTermination(1L, TimeUnit.HOURS);
} catch(InterruptedException e){
e.printStackTrace();
}
}
```
执行结果如下:
pool-1-thread-5
false
false
false
```

能够看到,前面2个任务提交的时候,队列中并没有内容,之后则一直有内容。很好的验证了第一条。
最后5行,则是异常后输出的内容,可以看出`threadPoolExecutor`仍在进行,但新提交的任务则被拒绝执行。- 其实这里应该吧try-catch放到循环里面,这样可以看到后续的提交都失败了。
感兴趣的可以自己试一下,同时输出下e.printStackTrace()。
## 其他
其实`ThreadPoolExecutor`的状态设计非常赞,不过那是另外的事了。
套用网友一句话,“李大爷设计的api,很巧妙,处处是坑”,哈哈。

稍稍解读下ThreadPoolExecutor的更多相关文章

  1. 稍稍解读下JDK8的HashMap

    首先,源码中上来就有一大段注释,但最重要的就是第一句. 大意如下: 本map经常用作一个 binned (bucketed) hash table (下面有解释),但是,当bins很大的时候,它们会被 ...

  2. weex官方demo weex-hackernews代码解读(下)

    weex 是阿里出品的一个类似RN的框架,可以使用前端技术来开发移动应用,实现一份代码支持H5,IOS和Android.而weex-hacknews则是weex官方出品的,首个使用 Weex 和 Vu ...

  3. SpringBoot项目框架下ThreadPoolExecutor线程池+Queue缓冲队列实现高并发中进行下单业务

    主要是自己在项目中(中小型项目) 有支付下单业务(只是办理VIP,没有涉及到商品库存),目前用户量还没有上来,目前没有出现问题,但是想到如果用户量变大,下单并发量变大,可能会出现一系列的问题,趁着空闲 ...

  4. jquery对div元素进行鼠标移动(稍稍修改下可以实现div跟随鼠标)

    /* 网上找了资料都是对于event.clientX和offset().left进行了计算,但是去掉了这个计算方式,直接使用当前坐标也一样,效果都一样不太好 strHeader:标题 jquery定位 ...

  5. 线程池ThreadPoolExecutor源码分析

    在阿里编程规约中关于线程池强制了两点,如下: [强制]线程资源必须通过线程池提供,不允许在应用中自行显式创建线程.说明:使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销,解决资源 ...

  6. 【转】 解读EOF

    解读EOF 标签: fplinuxc语言filestream 2012-01-31 22:05 439人阅读 评论(0) 收藏 举报  分类: C.C++_程序设计(20)  我学习C语言的时候,遇到 ...

  7. jdk1.8 ThreadPoolExecutor实现机制分析

    ThreadPoolExecutor几个重要的状态码字段 private static final int COUNT_BITS = Integer.SIZE - 3; private static ...

  8. Java Executor并发框架(二)剖析ThreadPoolExecutor运行过程

    上一篇从整体上介绍了Executor接口,从上一篇我们知道了Executor框架的最顶层实现是ThreadPoolExecutor类,Executors工厂类中提供的newScheduledThrea ...

  9. Nginx 模块开发(1)—— 一个稍稍能说明问题模块开发 Step By Step 过程

    1. Nginx 介绍        Nginx是俄罗斯人编写的十分轻量级的HTTP服务器,它的发音为“engine X”, 是一个高性能的HTTP和反向代理服务器,同时也是一个IMAP/POP3/S ...

随机推荐

  1. codeforces895E. Eyes Closed

    题目链接 codeforces895E. Eyes Closed 题解 线段树维护期望和 写出修改两区间的相互影响 就是一个区间修改 emmm考试的代码过不去,这么松的spj都过不去Orz,每次和答案 ...

  2. 闪烁的LED灯

    /* Main.c file generated by New Project wizard * * Created: 周五 五月 5 2017 * Processor: 80C31 * Compil ...

  3. android:应用性能优化SparseArray

    HashMap是java里比较常用的一个集合类,我比较习惯用来缓存一些处理后的结果.最近在做一个Android项目,在代码中定义这样一个变量,实例化时,Eclipse却给出了一个 performanc ...

  4. firedac数据集数据序列为JSON

    firedac数据集数据序列为JSON FIREDAC数据库引擎充分地考虑了跨平台和跨语言的支持. 因此,FIREDAC数据集可以序列为BIN\XML\JSON,三种格式. firedac数据集数据序 ...

  5. Python报错:ImportError: No module named src.data_layer

    ImportError: No module named src.data_layer 解决方案: export PYTHONPATH=path/to/modules

  6. Go语言之高级篇beego框架之model设计构造查询

    一.model设计构造查询 QueryBuilder 提供了一个简便,流畅的 SQL 查询构造器.在不影响代码可读性的前提下用来快速的建立 SQL 语句. QueryBuilder 在功能上与 ORM ...

  7. Go语言之高级篇beego框架之请求数据处理

    1.Controller中数据参数处理 获取参数:我们经常需要获取用户传递的数据,包括 Get.POST 等方式的请求,beego 里面会自动解析这些数据,你可以通过如下方式获取数据: GetStri ...

  8. tensorflow之数据读取探究(2)

    tensorflow之tfrecord数据读取 Tensorflow关于TFRecord格式文件的处理.模型的训练的架构为: 1.获取文件列表.创建文件队列:http://blog.csdn.net/ ...

  9. 如何用 async 控制流程

    来自: http://larry850806.github.io/2016/05/31/async/ [Javascript] 如何用 async 控制流程 (一) 31 May 2016 async ...

  10. Windows Server 2012 R2 或 2016 无法安装 .NET Framework 3.5.1

    问题描述 使用 Windows Server 2012 R2 或 Windows Server 2016系统,发现在安装 .NET Framework 3.5.1 时报错,报错内容如下图所示. 原因分 ...