Executor框架
在HotSpot VM的线程模型中，Java线程被一对一映射为本地操作系统线程，Java线程启动时会创建一个本地OS线程；当该Java线程终止时，这个OS线程也会被回收。OS会调度所有线程并将它们分配给可用的CPU。
在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定数量的线程；在底层，OS内核(OSKernel)将这些线程映射到硬件处理器上。
Executor框架的结构与成员
Executor是一个接口，它是Executor框架的基础，它负责任务的提交与任务的执行分离。
Executor框架主要由3大部分组成：
（1）任务。包括被执行任务需要实现的接口：Runnable接口或Callable接口
（2）任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的 ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口 （ThreadPoolExecutor和ScheduledThreadPoolExecutor）。
（2-1）ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务；
（2-2）ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。
Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。
（3）异步计算的结果。包括接口Future和实现Future接口的FutureTask类
Executor框架的使用
任务的创建
主线程首先要创建实现Runnable或者Callable接口的任务对象，其中工具类Executors可以把一 个Runnable对象封装为一个Callable对象（Executors.callable（Runnable task）或 Executors.callable（Runnable task，Object resule））。
执行任务
（1）把任务对象交给ExecutorService执行（ExecutorService.execute（Runnable command））；
（2）或者也可以把Runnable对象或Callable对象提交给ExecutorService执行（ExecutorService.submit（Runnable task）或ExecutorService.submit（Callabletask）），submit方法会返回一个实现Future接口的对象 ；
（3）由于FutureTask实现了Runnable，我们也可以创建FutureTask，然后直接交给ExecutorService执行。
等待任务的执行
主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行 FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。
Executor框架的主要成员
ThreadPoolExecutor
ThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建3种类型的 ThreadPoolExecutor：
（1）FixedThreadPool
创建使用固定线程数的方法如下。它适用于为满足资源管理，而需要限制当前线程数量的应用场景。如负载较重的服务器。
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)（2）SingleThreadExecutor
创建使用单个线程的方法如下。它适用于需要保证顺序地执行各个任务，并且在任意时间点，不会有多个线程是活动的应用场景。
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)（3）CachedThreadPool
创建一个会根据需要而创建新线程的方法如下。它是大小无界的线程池，适用于执行很多的短期异步任务的小程序，或是负载较轻的服务器。
public static ExecutorService newCachedThreadPool()
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
//Executors.newCachedThreadPool()
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
/*
CacheThreadPool的运行流程为：
（1）提交任务进线程池
（2）由于corePoolSize为0的关系，不创建核心线程，线程池最大为Integer.MAX_VALUE。
（3）试将任务添加到SynchronousQueue队列。
（4）如果SynchronousQueue入列成功，等待被当前运行的线程空闲后拉取执行。如果当前没有空闲线程，
那么就创建一个非核心线程，然后从SynchronousQueue拉取任务并在当前线程执行。
（5）果SynchronousQueue已有任务在等待，入列操作将会阻塞。
*/ScheduledThreadPoolExecutor
ScheduledThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建2种类型的ScheduledThreadPoolExecutor：
（1）ScheduledThreadPoolExecutor
它适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程数量的场景。它包含若干个线程
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize,ThreadFactory factory)（2）SingleThreadScheduledExecutor
它适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。
public static ScheduledExecutorService newSingleThreadScheduledExecutor()
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)Runnable接口和Callable接口
Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。它们之间的区别是Runnable不会返回结果，而Callable可以返回结果。
我们可以使用工厂类Executors来把一个 Runnable包装成一个Callable。
public static Callable<Object> callable(Runnable task)也可以把一个Runnable和一个待返回的结果包装成一个Callable
public static <T> Callable<T> callable(Runnable task, T result)Future接口
Future接口和实现Future接口的FutureTask类用来表示异步计算的结果。当我们把Runnable 接口或Callable接口的实现类通过submit方法提交给ThreadPoolExecutor或 ScheduledThreadPoolExecutor时，ThreadPoolExecutor或ScheduledThreadPoolExecutor会向我们 返回一个FutureTask对象。
<T> Future<T> submit(Callable<T> task)
<T> Future<T> submit(Runnable task, T result)
Future<> submit(Runnable task)
线程池ThreadPoolExecutor
为什么要使用线程池
（1）建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
（2）控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）
（3）对线程做统一管理。
线程池构造参数
先来看一下ThreadPoolExecutor构造函数中的7个参数，我们先介绍前5个必须的参数，然后再介绍后两个非必须参数。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) （1）int corePoolSize：该线程池中核心线程数最大值。线程池中有两类线程，核心线程和非核心线程。核心线程默认情况下会一直存在于线程池中，即使这个核心线程什么都不干；而非核心线程如果长时间的闲置，就会被销毁。
（2）int maximumPoolSize：该线程池中核心线程数量 + 非核心线程数量总数最大值 。
（3）long keepAliveTime：非核心线程闲置超时时长。如果设置allowCoreThreadTimeOut(true)，则会也作用于核心线程。
（4）TimeUnit unit：keepAliveTime的单位。TimeUnit是一个枚举类型，它包括：微毫秒NANOSECONDS，微秒MICROSECONDS ，毫秒MILLISECONDS ，SECONDS，MINUTES ，HOURS ，DAYS 。
（5）BlockingQueue workQueue：阻塞队列，维护着等待执行的Runnable任务对象。
常用的几个阻塞队列：
-
LinkedBlockingQueue
链式阻塞队列，底层数据结构是链表，默认大小是
Integer.MAX_VALUE，也可以指定大小。 -
ArrayBlockingQueue
数组阻塞队列，底层数据结构是数组，需要指定队列的大小。
-
SynchronousQueue
同步队列，内部容量为0，每个put操作必须等待一个take操作，反之亦然。
-
DelayQueue
延迟队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素 。
（6）ThreadFactory threadFactory：创建线程的工厂 ，用于批量创建线程，统一在创建线程时设置一些参数，如是否守护线程、线程的优先级等。如果不指定，会新建一个默认的线程工厂。
（7）RejectedExecutionHandler handler
拒绝处理策略，线程数量大于最大线程数就会采用拒绝处理策略，四种拒绝处理的策略为 ：
-
ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出RejectedExecutionException异常。
-
ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。
-
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列头部（最旧的）的任务，然后重新尝试执行程序（如果再次失败，重复此过程）。
-
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。
ThreadPoolExecutor的状态
线程池本身有一个调度线程，这个线程就是用于管理布控整个线程池里的各种任务和事务，例如创建线程、销毁线程、任务队列管理、线程队列管理等等。因此线程池也有自己的状态。ThreadPoolExecutor类中定义了一个volatile int变量runState来表示线程池的状态 ，分别为：
（1）线程池创建后处于RUNNING状态。
（2）调用shutdown()方法后处于SHUTDOWN状态，线程池不能接受新的任务，但能处理已添加的任务。
（3）调用shutdownNow()方法后处于STOP状态，线程池不能接受新的任务，中断所有线程，阻塞队列中没有被执行的任务全部丢弃。此时，poolsize=0,阻塞队列的size也为0。
（4）当所有的任务已终止，控制状态的属性ctl记录的”任务数量”为0，线程池会变为TIDYING状态。接着会执行terminated()函数
（5）线程池处在TIDYING状态时，执行完terminated()方法之后，就变成TERMINATED状态。此时线程池彻底终止。
线程池主要的任务处理流程
处理任务的核心方法是execute，下面是JDK1.8的execute方法源码：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 1.当前线程数小于corePoolSize,则调用addWorker创建核心线程执行任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 2.如果不小于corePoolSize，则将任务添加到workQueue队列。
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执行拒绝策略。
if (! isRunning(recheck) && remove(command))
reject(command);
// 2.2 线程池处于running状态，但是没有线程，则创建线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 3.如果放入workQueue失败，则创建非核心线程执行任务，
// 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时)，就会执行拒绝策略。
else if (!addWorker(command, false))
reject(command);
}为什么要二次检查线程池的状态?
在多线程的环境下，线程池的状态是时刻发生变化的。很有可能刚获取线程池状态后线程池状态就改变了。判断是否将command加入workqueue是线程池之前的状态。倘若没有二次检查，万一线程池处于非RUNNING状态（在多线程环境下很有可能发生），那么command永远不会执行。
总结一下处理流程：
（1）若线程总数量 < corePoolSize，无论线程是否空闲，都会新建一个核心线程执行任务。这一步骤需要获得全局锁。
（2）当线程总数量 >= corePoolSize时，新来的线程任务会进入任务队列中等待，然后空闲的核心线程会依次去缓存队列中取任务来执行（线程的复用）。
（3）当缓存队列满了，说明这个时候任务已经非常 多了，于是创建非核心线程去执行这个任务。这一步骤需要获得全局锁。
（4）如果缓存队列满了， 且总线程数达到了maximumPoolSize，则会采取拒绝策略进行处理。
ThreadPoolExecutor如何做到线程复用的
ThreadPoolExecutor在创建线程时，会将线程封装成工作线程worker,并放入工作线程组中，然后这个worker反复从阻塞队列中拿任务去执行。先来看一下上面调用的addWorker方法源码的上半部分，该部分主要判断线程数量是否超出阔值，若超出则返回false。
// ThreadPoolExecutor.addWorker方法源码上半部分
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
// 1.如果core是ture,证明需要创建的线程为核心线程，则先判断当前线程是否大于核心线程
// 如果core是false,证明需要创建的是非核心线程，则先判断当前线程数是否大于总线程数
// 如果不小于，则返回false
wc >= (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
}
}addWorker方法源码的下半部分如下。该部分创建worker对象并初始化，然后启动这个对象。
// ThreadPoolExecutor.addWorker方法源码下半部分
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 1.创建一个worker对象
w = new Worker(firstTask);
// 2.实例化一个Thread对象
final Thread t = w.thread;
if (t != null) {
// 3.线程池全局锁
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()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 4.启动这个线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}Worker类实现了Runnable接口，它也是一个线程任务，来看一下Woker类的部分源码
// Worker类部分源码
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
final Thread thread;
Runnable firstTask;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
//其余代码略...
}Woker类的run方法调用的是runWorker方法，该线程的任务就是自己。
下面是runWorker方法：首先去执行创建worker前已有的任务，执行完任务后，worker会在while循环中不断调用getTask方法从阻塞队列中获取任务然后调用task.run()执行任务,从而达到复用线程的目的。只要getTask方法不返回null,此线程就不会退出。
线程在取出阻塞队列中的任务前需要判断线程池的状态，如果是STOP或者TERMINATED，返回null。
// Worker.runWorker方法源代码
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// 1.线程启动之后，通过unlock方法释放锁
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 2.Worker执行firstTask或从workQueue中获取任务，如果getTask方法不返回null,循环不退出
while (task != null || (task = getTask()) != null) {
// 2.1进行加锁操作，保证thread不被其他线程中断（除非线程池被中断）
w.lock();
// 2.2检查线程池状态，倘若线程池处于中断状态，当前线程将中断。
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 2.3执行beforeExecute
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 2.4执行任务
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 {
// 2.5执行afterExecute方法
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
// 2.6解锁操作
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}最后看一下取出任务的getTask方法：
（1）核心线程会一直卡在workQueue.take方法，被阻塞并挂起，不会占用CPU资源，直到拿到Runnable 然后返回（如果allowCoreThreadTimeOut设置为true,那么核心线程就会去调用poll方法，因为poll可能会返回null,所以这时候核心线程如果满足超时条件，也会被销毁）。
（2）非核心线程会workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ，如果超时还没有拿到，下一次循环判断compareAndDecrementWorkerCount就会返回null,Worker对象的run()方法循环体的判断为null,任务结束，然后线程被系统回收 。
// Worker.getTask方法源码
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 1.allowCoreThreadTimeOut变量默认是false,核心线程即使空闲也不会被销毁
// 如果为true,核心线程在keepAliveTime内仍空闲则会被销毁。
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 2.如果运行线程数超过了最大线程数，但是缓存队列已经空了，这时递减worker数量。
// 如果有设置允许线程超时或者线程数量超过了核心线程数量，
// 并且线程在规定时间内均未poll到任务且队列为空，则递减worker数量
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 3.如果timed为true(想想哪些情况下timed为true),则会调用workQueue的poll方法获取任务.
// 超时时间是keepAliveTime。如果超过keepAliveTime时长，
// poll返回了null，上边提到的while循序就会退出，线程也就执行完了。
// 如果timed为false（allowCoreThreadTimeOut为falsefalse
// 且wc > corePoolSize为false），则会调用workQueue的take方法阻塞在当前。
// 队列中有任务加入时，线程被唤醒，take方法返回任务，并执行。
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
常见的线程池
之前我们曾简单的介绍ThreadPoolExecutor的3种类型，现在我们再来看一下这3种类型的构造方法
newCachedThreadPool
//Executors.newCachedThreadPool()
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}CacheThreadPool的运行流程为：
（1）提交任务进线程池
（2）由于corePoolSize为0的关系，不创建核心线程，线程池最大为Integer.MAX_VALUE。
（3）试将任务添加到SynchronousQueue队列。
（4）如果SynchronousQueue入列成功，等待被当前运行的线程空闲后拉取执行。如果当前没有空闲线程，那么就创建一个非核心线程，然后从SynchronousQueue拉取任务并在当前线程执行。
（5）果SynchronousQueue已有任务在等待，入列操作将会阻塞。
当需要执行很多短时间的任务时，CacheThreadPool的线程复用率比较高， 会显著的提高性能。而且线程60s后会回收，意味着即使没有任务进来，CacheThreadPool并不会占用很多资源。
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}核心线程数量和总线程数量都是传入的参数nThreads，因此只能创建核心线程。因为LinkedBlockingQueue的默认大小是Integer.MAX_VALUE，故如果核心线程空闲，则交给核心线程处理；如果核心线程不空闲，则入列等待，直到核心线程空闲。
与CachedThreadPool的区别：
（1）因为 corePoolSize == maximumPoolSize ，所以FixedThreadPool只会创建核心线程。 而CachedThreadPool因为corePoolSize=0，所以只会创建非核心线程。
（2）在 getTask() 方法，如果队列里没有任务可取，线程会一直阻塞在 LinkedBlockingQueue.take() ，线程不会被回收。 而CachedThreadPool会在60s后收回。
（3）由于线程不会被回收，会一直卡在阻塞，所以没有任务的情况下， FixedThreadPool占用资源更多。
（4）都几乎不会触发拒绝策略，但是原理不同。FixedThreadPool是因为阻塞队列可以很大（最大为Integer最大值），故几乎不会触发拒绝策略；CachedThreadPool是因为线程池很大（最大为Integer最大值），几乎不会导致线程数量大于最大线程数，故几乎不会触发拒绝策略。
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}有且仅有一个核心线程（ corePoolSize == maximumPoolSize=1），使用了LinkedBlockingQueue（容量很大），所以，不会创建非核心线程。所有任务按照先来先执行的顺序执行。如果这个唯一的线程不空闲，那么新来的任务会存储在任务队列里等待执行。
newScheduledThreadPool
这是一个可以支持定时及周期性执行任务的线程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
定时任务ScheduledThreadPoolExecutor
ScheduledThreadPoolExecutor继承ThreadPoolExecutor，并实现ScheduledExecutorService。它主要用于在给定的延迟之后运行任务，或者定期执行任务。
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor
implements ScheduledExecutorService {
public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue(), threadFactory);
}
//……
}其中接口ScheduledThreadPoolExecutor如下
public interface ScheduledExecutorService extends ExecutorService {
public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);
public <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit);
// 该方法在initialDelay时长后第一次执行任务，以后每隔period时长，再次执行任务。
// period是从任务开始执行算起的。
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
long initialDelay,
long period,
TimeUnit unit);
// 该方法在initialDelay时长后第一次执行任务，以后每当任务执行完成后，等待delay时长，
再次执行任务。
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit);
}
schedule方法
// delay时长后执行任务command，该任务只执行一次
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
if (command == null || unit == null)
throw new NullPointerException();
// 这里的decorateTask方法仅仅返回第二个参数
RunnableScheduledFuture<?> t = decorateTask(command,
new ScheduledFutureTask<Void>(command, null, triggerTime(delay,unit)));
// 延时或者周期执行任务的主要方法
delayedExecute(t);
return t;
}其中涉及到的ScheduledFuture、 RunnableScheduledFuture、 ScheduledFutureTask的关系如下图所示
Delayed接口
// 继承Comparable接口，表示该类对象支持排序
public interface Delayed extends Comparable<Delayed> {
// 返回该对象剩余时延
long getDelay(TimeUnit unit);
}ScheduledFuture接口
public interface ScheduledFuture<V> extends Delayed, Future<V> {
}RunnableScheduledFuture接口
public interface RunnableScheduledFuture<V> extends RunnableFuture<V>,
ScheduledFuture<V> {
// 是否是周期任务，周期任务可被调度运行多次，非周期任务只被运行一次
boolean isPeriodic();
}ScheduledFutureTask类
ScheduledFutureTask类实现了RunnableScheduledFuture接口和FutureTask类。
ScheduledFutureTask(Runnable r, V result, long ns, long period) {
// 调用父类FutureTask的构造方法
super(r, result);
// time表示任务下次执行的时间
this.time = ns;
// 周期任务，正数表示按照固定速率，负数表示按照固定时延,0表示不是周期任务
this.period = period;
// 任务的编号
this.sequenceNumber = sequencer.getAndIncrement();
}（1）ScheduledFutureTask类对Delayed接口的getDelay方法实现如下：
//返回任务开始执行的剩余时间
public long getDelay(TimeUnit unit) {
return unit.convert(time - now(), TimeUnit.NANOSECONDS);
}（2）ScheduledFutureTask类对Comparable接口的实现如下：
//比较两个任务的”大小”
public int compareTo(Delayed other) {
if (other == this)
return 0;
if (other instanceof ScheduledFutureTask) {
ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
long diff = time - x.time;
// 小于0，说明当前任务的执行时间点早于other，要排在延时队列other的前面
if (diff < 0)
return -1;
// 大于0，说明当前任务的执行时间点晚于other，要排在延时队列other的后面
else if (diff > 0)
return 1;
// 如果两个任务的执行时间点一样，比较两个任务的编号，编号小的排在队列前面，编号大的排在队列后面
else if (sequenceNumber < x.sequenceNumber)
return -1;
else
return 1;
}
// 如果任务类型不是ScheduledFutureTask，通过getDelay方法比较
long d = (getDelay(TimeUnit.NANOSECONDS) -
other.getDelay(TimeUnit.NANOSECONDS));
return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
}（3）ScheduledFutureTask类对Runnable接口的实现
public void run() {
boolean periodic = isPeriodic();
// 如果当前状态下不能执行任务，则取消任务
if (!canRunInCurrentRunState(periodic))
cancel(false);
// 不是周期性任务，执行一次任务即可，调用父类的run方法
else if (!periodic)
ScheduledFutureTask.super.run();
// 是周期性任务，调用FutureTask的runAndReset方法，方法执行完成后
// 重新设置任务下一次执行的时间，并将该任务重新入队，等待再次被调度
else if (ScheduledFutureTask.super.runAndReset()) {
setNextRunTime();
reExecutePeriodic(outerTask);
}
}
// 任务执行完后，设置下次执行的时间
private void setNextRunTime() {
long p = period;
// p > 0，说明是固定速率运行的任务
// 在原来任务开始执行时间的基础上加上p即可
if (p > 0)
time += p;
// p < 0，说明是固定时延运行的任务，
// 下次执行时间在当前时间(任务执行完成的时间)的基础上加上-p的时间
else
time = triggerTime(-p);
}scheduledAtFixedRate方法
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
long initialDelay,
long period,
TimeUnit unit) {
if (command == null || unit == null)
throw new NullPointerException();
if (period <= 0)
throw new IllegalArgumentException();
// 创建一个有初始延时和固定周期的任务
ScheduledFutureTask<Void> sft =
new ScheduledFutureTask<Void>(command,
null,
triggerTime(initialDelay, unit),
unit.toNanos(period));
RunnableScheduledFuture<Void> t = decorateTask(command, sft);
// outerTask表示将会重新入队的任务
sft.outerTask = t;
delayedExecute(t);
return t;
delayedExecute方法
delayedExecute方法是定时任务执行的主要方法
//将任务添加到等待队列，然后调用ensurePrestart方法。
private void delayedExecute(RunnableScheduledFuture<?> task) {
// 线程池已经关闭，调用拒绝执行处理器处理
if (isShutdown())
reject(task);
else {
// 将任务加入到等待队列
super.getQueue().add(task);
// 线程池已经关闭，且当前状态不能运行该任务，将该任务从等待队列移除并取消该任务
if (isShutdown() &&
!canRunInCurrentRunState(task.isPeriodic()) &&
remove(task))
task.cancel(false);
else
// 增加一个worker，就算corePoolSize=0也要增加一个worker
ensurePrestart();
}
}
//线程池中的工作线程是通过addWorker()方法来启动并执行任务
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
addWorker(null, true);
else if (wc == 0)
addWorker(null, false);
}
参考资料
http://concurrent.redspider.group/
扫一扫
883
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
