前边两章介绍了基础线程池ThreadPoolExecutor的使用方式、工作机理、参数详细介绍以及核心源码解析。

具体的介绍请参照:

第十二章 ThreadPoolExecutor使用与工作机理

第十三章 ThreadPoolExecutor源码解析

1、Executors与ThreadPoolExecutor

  • ThreadPoolExecutor

    • 可以灵活的自定义的创建线程池,可定制性很高
    • 想创建好一个合适的线程池比较难
    • 使用稍微麻烦一些
    • 实际中很少使用
  • Executors
    • 可以创建4种线程池,这四种线程池基本上已经包含了所有需求,将来根据业务特点选用就好
    • 使用非常简单
    • 实际中很常用

使用方法:

package com.collection.test;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors; public class ThreadPoolExecutorTest {
//private static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
//private static Executor executor = Executors.newFixedThreadPool(5);
//private static Executor executor = Executors.newSingleThreadExecutor();
//private static Executor executor = Executors.newCachedThreadPool();
private static Executor executor = Executors.newScheduledThreadPool(5); public void executeTask(){
Task1 task1 = new Task1();//构建任务1
Task2 task2 = new Task2();//构建任务2
executor.execute(task1);//执行任务1
executor.execute(task2);//执行任务2
} /*
* 基本任务2
*/
class Task1 implements Runnable{
public void run() {
//具体任务的业务
for(int i=0;i<1000;i++){
System.out.println("hello xxx!!!");
}
}
} /*
* 基本任务2
*/
class Task2 implements Runnable{
public void run() {
//具体任务的业务
for(int i=0;i<5;i++){
System.out.println("hello world2!!!");
}
}
} public static void main(String[] args) {
ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
test.executeTask();
}
}

2、Executors可以创建的几种线程池简介

  • newFixedThreadPool(int corePoolSize)

    • 创建一个线程数固定(corePoolSize==maximumPoolSize)的线程池
    • 核心线程会一直运行
    • 如果一个核心线程由于异常跪了,会新创建一个线程
    • 无界队列LinkedBlockingQueue
  • newSingleThreadExecutor
    • 创建一个线程数固定(corePoolSize==maximumPoolSize==1)的线程池
    • 核心线程会一直运行
    • 无界队列LinkedBlockingQueue
    • 所有task都是串行执行的(即同一时刻只有一个任务在执行)
  • newCachedThreadPool
    • corePoolSize==0
    • maximumPoolSize==Integer.MAX_VALUE
    • 队列:SynchronousQueue
    • 创建一个线程池:当池中的线程都处于忙碌状态时,会立即新建一个线程来处理新来的任务
    • 这种池将会在执行许多耗时短的异步任务的时候提高程序的性能
    • 6秒钟内没有使用的线程将会被中止,并且从线程池中移除,因此几乎不必担心耗费资源
  • newScheduledThreadPool(int corePoolSize)
    • 用于执行定时或延迟执行的任务,最典型的:异步操作时的超时回调

注意:对于定时任务的执行,在实际使用中,会去使用spring定时器,非常方便

3、newFixedThreadPool(int corePoolSize)

源代码:

    /**
* 1、创建一个线程数固定(corePoolSize==maximumPoolSize)的线程池,
* 2、核心线程会一直运行
* 3、无界队列LinkedBlockingQueue
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

说明:execute()的源代码查看第十三章 ThreadPoolExecutor源码解析

4、newSingleThreadExecutor()

源代码:

    /**
* 1、创建一个线程数固定(corePoolSize==maximumPoolSize==1)的线程池
* 2、核心线程会一直运行
* 3、无界队列LinkedBlockingQueue
* 注意:所有task都是串行执行的
*/
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}

说明:execute()的源代码查看第十三章 ThreadPoolExecutor源码解析

5、newCachedThreadPool()

源代码:

    /**
* 1、创建一个线程池:当池中的线程都处于忙碌状态时,会立即新建一个线程来处理新来的任务
* 2、这种池将会在执行许多耗时短的异步任务的时候提高程序的性能。
* 3、6秒钟内没有使用的线程将会被中止,并且从线程池中移除,因此几乎不必担心耗费资源
* 4、队列:SynchronousQueue
* 5、maximumPoolSize为Integer.MAX_VALUE
*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}

说明:execute()的源代码查看第十三章 ThreadPoolExecutor源码解析

6、newScheduledThreadPool(int corePoolSize)

源代码:

Executors:newScheduledThreadPool(int corePoolSize)

    /**
* 创建一个线程池:该线程池可以用于执行延时任务或者定时任务
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}

ScheduledThreadPoolExecutor:ScheduledThreadPoolExecutor(int corePoolSize)

    /**
* 创建一个线程池:
* corePoolSize==我们指定
* maximumPoolSize==Integer.MAX_VALUE
* keepAliveTime==0纳秒(即不回收闲置线程)
* 队列: DelayedWorkQueue
*/
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
new DelayedWorkQueue());
}

说明:ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类,其中调用的super构造器就是ThreadPoolExecutor的构造器。

ScheduledThreadPoolExecutor:execute(Runnable command)

    public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
schedule(command, 0, TimeUnit.NANOSECONDS);
}

ScheduledThreadPoolExecutor:schedule(Runnable command, long delay, TimeUnit unit)

    /**
* 这个方法:其实就是将task封装一下,然后加入到DelayedWorkQueue中
* 1、DelayedWorkQueue其实就是一个DelayQueue
* 2、当有新的task加入时,DelayQueue会将其加入内部的数组对象中,并对其进行排序,在这里,排序的规则就是执行的时间,执行时间越近的排在越前
* 3、线程池中的线程在执行task时,获取最近要执行的task,然后唤醒所有等待available条件的线程来执行该任务
*/
public ScheduledFuture<?> schedule(Runnable command,
long delay,
TimeUnit unit) {
if (command == null || unit == null)
throw new NullPointerException();
RunnableScheduledFuture<?> t = decorateTask(command,
new ScheduledFutureTask<Void>(command, null, triggerTime(delay, unit))); delayedExecute(t);
return t;
}

注意:这里的注释就是整个ScheduledThreadPoolExecutor的执行机理。

下面说一下其中调用到的一些方法。

第一部分:封装ScheduledFutureTask任务

ScheduledThreadPoolExecutor:triggerTime(long delay, TimeUnit unit)

    /**
* 返回一个delayed action(延时任务)的触发时间
*/
private long triggerTime(long delay, TimeUnit unit) {
return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
} /**
* Returns the trigger time of a delayed action.
*/
long triggerTime(long delay) {
return now() +
((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
}

说明:用于计算延时任务的触发时间。

注意:在上边的execute()方法中传递的delay是0,根据上边的代码,计算出触发时间就是now()。

ScheduledThreadPoolExecutor:内部类ScheduledFutureTask

    private class ScheduledFutureTask<V>
extends FutureTask<V> implements RunnableScheduledFuture<V> { private final long sequenceNumber;//用于打破FIFO关系的序列号
private long time;//任务执行的触发时间
/**
* 一个用于重复执行的任务的时间段(单位:纳秒)
* 0-->不重复执行的任务
* 正值:fixed-rate执行
* 负值:fixed-delay执行
*/
private final long period; /**
* 创建一个一次性的action并且指定触发时间
*/
ScheduledFutureTask(Runnable r, V result, long ns) {
super(r, result);
this.time = ns;
this.period = 0;
this.sequenceNumber = sequencer.getAndIncrement();
}

说明:ScheduledFutureTask是FutureTask的子类,上边的构造器中的super(r, result)代码如下:

FutureTask:FutureTask(Runnable runnable, V result)

    private final Sync sync;//控制FutureTask的同步器

    public FutureTask(Runnable runnable, V result) {
sync = new Sync(Executors.callable(runnable, result));
}

Executors:callable(Runnable task, T result)

    public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}

Executors:内部类RunnableAdapter

    static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();//这里是真正的task运行的地方
return result;
}
}

注意:这里才是task真正去运行的地方。-->task.run()

至此,ScheduledFutureTask任务封装完成。

第二部分:修饰任务

ScheduledThreadPoolExecutor:RunnableScheduledFuture

    protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable,
RunnableScheduledFuture<V> task) {
return task;
}

说明:这里其实就是直接返回了刚刚封装好的任务

第三部分:将延时任务加入阻塞队列

ScheduledThreadPoolExecutor:delayedExecute(Runnable command)

    private void delayedExecute(Runnable command) {
if (isShutdown()) {//return runState != RUNNING;线程池状态不是RUNNING
reject(command);//回绝任务
return;
} if (getPoolSize() < getCorePoolSize())//当前线程池数量少于核心线程数
prestartCoreThread();//创建并启动一个核心线程 super.getQueue().add(command);//获取阻塞队列,并将command加入队列
}

说明:这样之后,之前封装好的任务就加入了延时队列DelayQueue(阻塞队列的一个子类)

DelayQueue:add(E e)

    public boolean add(E e) {
return offer(e);
} public boolean offer(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
E first = q.peek();//获取队列头部节点但不删除
q.offer(e);//将e放到q的尾部
//如果队列中只有e或者e的触发时间小于队头结点
if (first == null || e.compareTo(first) < 0)
available.signalAll();
return true;
} finally {
lock.unlock();
}
}

说明:在该方法中,将上边封装好的任务就加入了DelayQueue,并将该任务置于了队头,然后唤醒所有等待available条件的线程来执行该任务。

总结:

  • 四种线程池最常用的就是newCachedThreadPool和newFixedThreadPool(int corePoolSize)
  • 对于newScheduledThreadPool(int corePoolSize)使用比较少,因为在现代开发中,如果用于去开发定时任务程序的话,用spring定时器会非常简单

第十四章 Executors源码解析的更多相关文章

  1. 第四章 CopyOnWriteArraySet源码解析

    注:在看这篇文章之前,如果对CopyOnWriteArrayList底层不清楚的话,建议先去看看CopyOnWriteArrayList源码解析. http://www.cnblogs.com/jav ...

  2. 第六章 ReentrantLock源码解析2--释放锁unlock()

    最常用的方式: int a = 12; //注意:通常情况下,这个会设置成一个类变量,比如说Segement中的段锁与copyOnWriteArrayList中的全局锁 final Reentrant ...

  3. 第九章 LinkedBlockingQueue源码解析

    1.对于LinkedBlockingQueue需要掌握以下几点 创建 入队(添加元素) 出队(删除元素) 2.创建 Node节点内部类与LinkedBlockingQueue的一些属性 static ...

  4. 第零章 dubbo源码解析目录

    第一章 第一个dubbo项目 第二章  dubbo内核之spi源码解析 2.1  jdk-spi的实现原理 2.2 dubbo-spi源码解析 第三章 dubbo内核之ioc源码解析 第四章 dubb ...

  5. 第十三章 ThreadPoolExecutor源码解析

    ThreadPoolExecutor使用方式.工作机理以及参数的详细介绍,请参照<第十二章 ThreadPoolExecutor使用与工作机理 > 1.源代码主要掌握两个部分 线程池的创建 ...

  6. Android进阶:四、RxJava2 源码解析 1

    本文适合使用过Rxjava2或者了解Rxjava2的基本用法的同学阅读 一.Rxjava是什么 Rxjava在GitHub 主页上的自我介绍是 "a library for composin ...

  7. 第二章 ConcurrentHashMap源码解析

    注:在看这篇文章之前,如果对HashMap的层不清楚的话,建议先去看看HashMap源码解析. http://www.cnblogs.com/java-zhao/p/5106189.html 1.对于 ...

  8. 第三章 CopyOnWriteArrayList源码解析

    注:在看这篇文章之前,如果对ArrayList底层不清楚的话,建议先去看看ArrayList源码解析. http://www.cnblogs.com/java-zhao/p/5102342.html ...

  9. 第六章 HashSet源码解析

    6.1.对于HashSet需要掌握以下几点 HashSet的创建:HashSet() 往HashSet中添加单个对象:即add(E)方法 删除HashSet中的对象:即remove(Object ke ...

随机推荐

  1. html+css制作五环(代码极简)

    五环 把五环做成一个浮动,总是位于屏幕中央的效果. 难点 定位的练习 position :fixed 位于body中间的时候 left:50%:top:50%; css内部样式表的使用 style=& ...

  2. redis 主要数据类型及使用

    1.类型 redis 的主要数据类型: 1.1 string 字符串类型<*是其它4种类型的基础> 1.2 hash 散列类型 1.3 list 列表类型 1.4 set 集合类型 1.5 ...

  3. Python 实现扫码二维码登录

    最近在做一个扫码登录功能,为此我还在网上搜了一下关于微信的扫描登录的实现方式.当这个功能完成了后,我决定将整个实现思路整理出来,方便自己以后查看也方便其他有类似需求的程序猿些. 要实现扫码登录我们需要 ...

  4. WinForm 使用 NPOI 2.2.1从datatable导出Excel

    最新的NOPI应该是2.3了,但在官网上还是2.2.1. 也是第一次使用NPOI来导出Excel文件. 在写的时候搜不到2.2.1的教程,搜了一个2.2.0的教程. 不过也没什么问题,NPOI是真的方 ...

  5. SQLSERVER——查看阻塞信息(sp_who_lock优化无误版)

    经常会需要分析SQLSERVER的阻塞情况,尤其是某些SQL操作异常缓慢从而怀疑是有人在搞事情的情况下.网上有许多一模一样的帖子,是关于sp_who_lock这个存储过程的,然而,网上流传的这个是略有 ...

  6. 【二分】【预处理】zoj4029 Now Loading!!!

    题意:给定一个序列,多次询问 将a数组从小到大排序,下面那个值只有不超过32种,于是预处理f[i][j],表示分母为i时,aj/i的前缀和是多少. 然后对于一个给定的p,一定将分母划分成了一些连续的段 ...

  7. 【数论】Codeforces Round #483 (Div. 2) [Thanks, Botan Investments and Victor Shaburov!] C. Finite or not?

    题意:给你一个分数,问你在b进制下能否化成有限小数. 条件:p/q假如已是既约分数,那么如果q的质因数分解集合是b的子集,就可以化成有限小数,否则不能. 参见代码:反复从q中除去b和q的公因子部分,并 ...

  8. python循环与判断

    学习一门新的语言最重要的就是练习. 一.脚本需求: 编写登陆接口 输入用户名密码 认证成功后显示欢迎信息 输错三次后锁定 二.脚本流程图: 写代码之前画个流程图总是好的,可以让你理清思路,避免写着写着 ...

  9. webpack入门(1)

    webpack入门(1) 源码戳这里 ps:每个案例对应相应的demo,例如"案例1"对应"demo1" 一.webpack基本功能及简单案例 安装webpac ...

  10. Mac使用自带的屏幕共享实现VNC连接KVM时需要输入密码的问题解决

    别试了,下载这个软件VNC-Viewer,苹果自带的那个不行!!! https://www.realvnc.com/en/connect/download/viewer/macos/