线程池与线程对比：
线程方式
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/***
* 使用线程的方式去执行程序
*/
public class ThreadTest {
public static void main(String[] args) throws InterruptedException {
Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 100000; i++) {
Thread thread = new Thread() {
@Override
public void run() {
list.add(random.nextInt());
}
};
thread.start();
thread.join();
}
System.out.println("时间：" + (System.currentTimeMillis() - start));
System.out.println("大小：" + list.size());
}
}
结果
时间：21787
大小：100000
线程池方式
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/***
* 线程池执行
*/
public class ThreadPoolTest {
public static void main(String[] args) throws InterruptedException {
Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 100000; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
list.add(random.nextInt());
}
});
}
executorService.shutdown();
executorService.awaitTermination(1, TimeUnit.DAYS);
System.out.println("时间："+(System.currentTimeMillis() - start));
System.out.println("大小："+list.size());
}
}
结果
时间：47
大小：100000
为什么要自己定义线程池
虽然jdk提供了几种常用特性的线程池给我们，但是很多时候，我还是需要自己去自定义自己需要特征的线程池。
并且阿里巴巴规范手册里面，就是不建议使用jdk的线程池，而是建议程序员手动创建线程池。
说明：Executors 返回的线程池对象的弊端如下：
1、FixedThreadPool 和 SingleThreadPool:
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2、CachedThreadPool 和 ScheduledThreadPool:
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM
但是除此之外，自己通过ThreadPoolExecutor定义线程池还有很多好处。
比如说，
1.自己根据需求定义自己的拒绝策略，如果线程过多，任务过多 如何处理。
2.补充完善的线程信息，比如线程名，这一点在将来如果出现线上bug的时候，你会感谢自己，因为你绝不想在线上看到什么threa-1 threa-2 等这种线程爆出的错误，而且是看到自己 “处理xxx线程 错误”，可以一眼看到
3.可以通过ThreadPoolExecutor的beforExecute(),
afterExecute()和terminated()方法去拓展对线程池运行前，运行后，结束后等不同阶段的控制。比如说通过拓展打印日志输出一些有用的调试信息。在故障诊断是非常有用的。
4.可以通过自定义线程创建，可以自定义线程名称，组，优先级等信息，包括设置为守护线程等，根据需求。
自定义线程池
示例如下
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 有界任务队列。 有界任务队列可以使用ArrayBlockingQueue实现
*/
public class ThreadPoolDemo {
public static void main(String[] args) {
/**
* SynchronousQueue 直接提交队列,会导致oom
* 也就是如果使用SynchronousQueue，提交的任务不会被真实保存，而是将新任务交给空闲线程执行，
* 如果没有空闲线程，则创建线程，如果线程数都已经大于最大线程数，则执行拒绝策略。
* 使用这种队列，需要将maximumPoolSize设置的非常大，不然容易执行拒绝策略
* 但是这个在大量任务的时候，会启用等量的线程去处理，有风险造成系统资源不足
*/
ExecutorService executorService1 = Executors.newCachedThreadPool();//快
//LinkedBlockingQueue
ExecutorService executorService2 = Executors.newFixedThreadPool(10);//慢
//LinkedBlockingQueue
ExecutorService executorService3 = Executors.newSingleThreadExecutor();//最慢
/**
* 自定义线程池的参数
* @param corePoolSize 指定了线程池里的线程数量
* @param maximumPoolSize 指定了线程池里的最大线程数量
* @param keepAliveTime 当线程池线程数量大于corePoolSize时候，多出来的空闲线程，多长时间会被销毁。
* @param unit 时间单位
* @param workQueue 任务队列，用于存放提交但是尚未被执行的任务。
* @param threadFactory 线程工厂，用于创建线程，一般可以用默认的
* @param handler 拒绝策略，当任务过多时候，如何拒绝任务。
*
* 主要是workQueue和handler的差异比较大
*/
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(10),
Executors.defaultThreadFactory(), new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
// 写数据库的代码
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
executor.toString());
}
}
);
for (int i = 1; i <= 100; i++) {
threadPoolExecutor.execute(new MyTask(i));
}
}
}
/***
* 项目
*/
class MyTask implements Runnable {
int i = 0;
public MyTask(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "程序员做第" + i + "个项目");
try {
Thread.sleep(3000L);//业务逻辑
} catch (Exception e) {
e.printStackTrace();
}
}
}
主要是workQueue和handler的差异比较大
BlockingQueue
workQueue指被提交但未执行的任务队列，它是一个BlockingQueue接口的对象，仅用于存放Runnable对象。
ThreadPoolExecutor的构造函数中，可使用以下几种BlockingQueue
1.直接提交队列： 即SynchronousQueue ,这是一个比较特殊的BlockKingQueue， SynchronousQueue没有容量，每一个插入操作都要等待对应的删除操作，反之 一个删除操作都要等待对应的插入操作。 也就是如果使用SynchronousQueue，提交的任务不会被真实保存，而是将新任务交给空闲线程执行，如果没有空闲线程，则创建线程，如果线程数都已经大于最大线程数，则执行拒绝策略。使用这种队列，需要将maximumPoolSize设置的非常大，不然容易执行拒绝策略。比如说
没有最大线程数限制的newCachedThreadPool()
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
但是这个在大量任务的时候，会启用等量的线程去处理，有风险造成系统资源不足。
2.有界任务队列。 有界任务队列可以使用ArrayBlockingQueue实现。需要给一个容量参数表示该队列的最大值。当有新任务进来时，如果当前线程数小于corePoolSize，则会创建新线程执行任务。如果大于，则会将任务放到任务队列中，如果任务队列满了，在当前线程小于将maximumPoolSize的情况下，将会创建新线程，如果大于maximumPoolSize，则执行拒绝策略。
也就是，一阶段，当线程数小于coresize的时候，创建线程；二阶段，当线程任务数大于coresize的时候，放入到队列中；三阶段，队列满，但是还没大于maxsize的时候，创建新线程。 四阶段，队列满，线程数也大于了maxsize, 则执行拒绝策略。
可以发现，有界任务队列，会大概率将任务保持在coresize上，只有队列满了，也就是任务非常繁忙的时候，会到达maxsie。
3.无界任务队列。
使用linkedBlockingQueue实现，队列最大长度限制为integer.MAX。无界任务队列，不存在任务入队失败的情况， 当任务过来时候，如果线程数小于coresize ，则创建线程，如果大于，则放入到任务队列里面。也就是，线程数几乎会一直维持在coresize大小。FixedThreadPool和singleThreadPool即是如此。 风险在于，如果任务队列里面任务堆积过多，可能导致内存不足。
4.优先级任务队列。使用PrioriBlockingQueue ，特殊的无界队列，和普通的先进先出队列不同，它是优先级高的先出。
因此 ，自定义线程池的时候，应该根据实际需要，选择合适的任务队列应对不同的场景。
jdk内置的拒绝策略
如下：
ThreadPoolExecutor内部有实现4个拒绝策略：
- CallerRunsPolicy，由调用execute方法提交任务的线程来执行这个任务；
- AbortPolicy，抛出异常RejectedExecutionException拒绝提交任务；
- DiscardPolicy，直接抛弃任务，不做任何处理；
- DiscardOldestPolicy，去除任务队列中的第一个任务（最旧的），重新提交；
jdk内置的几种线程池，默认采用的是AbortPolicy 策略，会直接抛出异常,defaultHandler如下。
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
public static class AbortPolicy implements RejectedExecutionHandler {
/**
* Creates an {@code AbortPolicy}.
*/
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());
}
}
以上内置的策略均实现了RejectedExecutionHandler接口，因此我们也可以实现这个接口，自定义我们自己的策略。
最后的最后，所有的线程池里面，线程是从哪里来的？
答案是ThreadFactory
这个是一个接口，里面只有一个方法，用来创建线程
public interface ThreadFactory {
Thread newThread(Runnable r);
}
//默认实现
public static ThreadFactory defaultThreadFactory() {
return new DefaultThreadFactory();
}
线程池的默认ThreadFactory如下
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
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;
}
}
同理我们也可以通过实现ThreadFactory来定义我们自己的线程工厂，比如说自定义线程名称，组，优先级等信息，可以跟着线程池究竟在何时创建了多少线程等等。
源码分析
execute方法：
//runnable为线程内的任务
public void execute(Runnable command) {
//为null则抛出异常
if (command == null)
throw new NullPointerException();
//获取工作的线程数量和线程状态
//private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
int c = ctl.get();
//判断当前的线程数是否小于corePoolSize,如果是，使用入参任务通过addWord方法创建一个新的线程，
//如果能完成新线程创建exexute方法结束，成功提交任务；
if (workerCountOf(c) < corePoolSize) {
//addWorker 直接执行新线程
if (addWorker(command, true))
return;
c = ctl.get();
}
//在第一步没有完成任务提交；状态为运行并且能成功加入任务到工作队列后，
//如果大于corsize 则放到等待队列中,workQueue.offer()表示放到队列中
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//再进行一次check，如果状态在任务加入队列后变为了非运行（有可能是在执行到这里线程池shutdown了）
if (! isRunning(recheck) && remove(command))
reject(command);
//判断当前工作线程池数是否为0
else if (workerCountOf(recheck) == 0)
//如果是创建一个null任务，任务在堵塞队列存在了就会从队列中取出 这样做的意义是保证线程池在running状态必须有一个任务在执行
addWorker(null, false);
}
//如果放到队列中失败，直接提交给线程池执行,如果提交失败，则执行reject() 拒绝策略
else if (!addWorker(command, false))
reject(command);
}
ctl.get()
ctl.get()就是取出线程数量和运行状态,然后把workerCount的数量和corePoolSize比较,如果<,进addWorker方法,并重新ctl.get()
在这里我们需要了解一下线程池的常用属性,代码如下
//前面3个bit是用来表示线程池的状态,其余29个bit用于workerCount的计数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//public static final int SIZE = 32;
private static final int COUNT_BITS = Integer.SIZE - 3;
//536870911 0001 1111 1111 1111 1111 1111 1111 1111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// COUNT_BITS 变量为什么要减 3：因为线程池的生命周期有 5 个状态，为了表达这 5 个状态，我们需要 3 个二进制位
// RUN_STATE is stored in the high-order bits
//RUNNING状态 1110 0000 0000 0000 0000 0000 0000 0000
private static final int RUNNING = -1 << COUNT_BITS;
//SHUTDOWN状态 0000 0000 0000 0000 0000 0000 0000 0000
private static final int SHUTDOWN = 0 << COUNT_BITS;
//STOP状态 0010 0000 0000 0000 0000 0000 0000 0000
private static final int STOP = 1 << COUNT_BITS;
//TIDYING状态 0100 0000 0000 0000 0000 0000 0000 0000
private static final int TIDYING = 2 << COUNT_BITS;
//TERMINATED状态 0110 0000 0000 0000 0000 0000 0000 0000
private static final int TERMINATED = 3 << COUNT_BITS;
// Packing and unpacking ctl
//对 CAPACITY 进行 ~ (按位取反)操作后，再和 ctl 进行 & 操作就能取到 runState 。它的高 3 位是 ctl 的高 3 位，低 29 位为 0
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 对 CAPACITY 和 ctl 进行 & (按位与)操作就能取到 ctl 的后 29 位，即 workerCount
private static int workerCountOf(int c) { return c & CAPACITY; }
//常量初始化时左移提高了打包函数的效率：此处可以直接对 runState 和 workerCount 进行 | (按位或)操作来得到 ctl 变量，
//因为 runState 的高3位为有效信息(111)，而 workerCount 的低 29 位为有效信息，合起来正好得到一个含 32 位有效信息的整型变量
private static int ctlOf(int rs, int wc) { return rs | wc; }
addWorker方法
addWorker方法的主要工作是在线程池中创建一个新的线程并执行，firstTask参数 用于指定新增的线程执行的第一个任务，core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize，代码如下：
/*
* addWorker中的第二个参数表示限制添加线程的数量是根据corePoolSize来判断还是maximumPoolSize来判断；
* 如果为true，根据corePoolSize来判断；
* 如果为false，则根据maximumPoolSize来判断
*/
private boolean addWorker(Runnable firstTask, boolean core) {
//goto写法 用于重试
retry:
for (;;) {
//线程数量和线程状态
int c = ctl.get();
// 获取运行状态
int rs = runStateOf(c);
/*
* 这个if判断
* 如果rs >= SHUTDOWN，则表示此时不再接收新任务；
* 接着判断以下3个条件，只要有1个不满足，则返回false：
* 1. rs == SHUTDOWN，这时表示关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务
* 2. firsTask为空
* 3. 阻塞队列不为空
*
* 首先考虑rs == SHUTDOWN的情况
* 这种情况下不会接受新提交的任务，所以在firstTask不为空的时候会返回false；
* 然后，如果firstTask为空，并且workQueue也为空，则返回false，
* 因为队列中已经没有任务了，不需要再添加线程了
*/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
// 获取线程数
int wc = workerCountOf(c);
// 如果wc超过CAPACITY，也就是ctl的低29位的最大值（二进制是29个1），返回false；
// 这里的core是addWorker方法的第二个参数，如果为true表示根据corePoolSize来比较，
// 如果为false则根据maximumPoolSize来比较。
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 尝试增加workerCount，如果成功，则跳出最外层的for循环
//cas操作 如果为true 新增成功 退出循环,ctl+1 工作线程池数量+1 如果成功,跳出死循环。
if (compareAndIncrementWorkerCount(c))
//跳出死循环。
break retry;
// 如果增加workerCount失败，则重新获取ctl的值
c = ctl.get();
// 如果当前的运行状态不等于rs，说明状态已被改变，返回第一个for循环继续执行
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//上面主要是对ctl工作现场+1
//这里是两个标识,分别标识线程是否添加和启动成功
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//内部类 封装了线程和任务 通过threadfactory创建线程
w = new Worker(firstTask);
// 每一个Worker对象都会创建一个线程
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());
// rs < SHUTDOWN表示是RUNNING状态；
// 如果rs是RUNNING状态或者rs是SHUTDOWN状态并且firstTask为null，向线程池中添加线程。
// 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任务
if (rs < SHUTDOWN ||
// SHUTDOWN 和firstTask 为空是从队列中处理任务 那就可以放到集合中 线程还没start 就是alive就直接异常
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// workers是一个HashSet ,是ThreadPoolExecutor的属性
//private final HashSet<Worker> workers = new HashSet<Worker>();
workers.add(w);
//记录最大线程数
int s = workers.size();
// largestPoolSize记录着线程池中出现过的最大线程数量
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//启动线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
//失败回退 从wokers移除w 线程数减1 尝试结束线程池
addWorkerFailed(w);
}
return workerStarted;
}
compareAndIncrementWorkerCount(c)
就是cas操作
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
w = new Worker(firstTask)
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
//正在运行woker线程
final Thread thread;
//这里就是传入的任务
Runnable firstTask;
//完成的任务数 监控用
volatile long completedTasks;
Worker(Runnable firstTask) {
//禁止线程中断
setState(-1); // inhibit interrupts until runWorker
//这里就是传入的任务
this.firstTask = firstTask;
//这里getThreadFactory默认DefaultThreadFactory,
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
}
注意这里thread传入的是this,不是传入的任务
getThreadFactory()
/**
* The default thread factory
*/
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
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;
}
}
runwoker方法：
在Worker类中的run方法调用了runWorker方法来执行任务，runWorker方法的代码如下：
final void runWorker(Worker w) {
//获取当前线程
Thread wt = Thread.currentThread();
// 获取第一个任务,就是传入的任务传入的任务
的
Runnable task = w.firstTask;
w.firstTask = null;
// allow interrupts 把state从-1改为0 意思是可以允许中断
w.unlock();
// 是否因为异常退出循环
boolean completedAbruptly = true;
try {
//如果task为空，则通过getTask来获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
//如果当前线程池状态等于stop 就中断
//Thread.interrupted() 中断标志
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
//执行传入的任务传入的任务的run方法
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;
//完成任务数+1
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
总结一下runWorker方法的执行过程：
- while循环不断地通过getTask()方法获取任务；
- getTask()方法从阻塞队列中取任务；
- 如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态；
- 调用task.run()执行任务；
- 如果task为null则跳出循环，执行processWorkerExit()方法；
- runWorker方法执行完毕，也代表着Worker中的run方法执行完毕，销毁线程。
这里的beforeExecute方法和afterExecute方法在ThreadPoolExecutor类中是空的，留给子类来实现。
completedAbruptly变量来表示在执行任务过程中是否出现了异常，在processWorkerExit方法中会对该变量的值进行判断。
getTask方法：
private Runnable getTask() {
// timeOut变量的值表示上次从阻塞队列中取任务时是否超时
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
//获取线程池运行状态
int rs = runStateOf(c);
/*
* 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判断：
* 1. rs >= STOP，线程池是否正在stop；
* 2. 阻塞队列是否为空。
* 如果以上条件满足，则将workerCount减1并返回null。
* 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中添加任务。
*/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
//重新获取工作线程数
int wc = workerCountOf(c);
// timed变量用于判断是否需要进行超时控制。
// allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
// wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
// 对于超过核心线程数量的这些线程，需要进行超时控制
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
/*
* wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
* timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
* 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
* 如果减1失败，则返回重试。
* 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
*/
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
/*
* 根据timed来判断，如果为true，则通过阻塞队列的poll方法进行超时控制，
* 如果在keepAliveTime时间内没有获取到任务，则返回null；
* 否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为空。
*/
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
// 如果 r == null，说明已经超时，timedOut设置为true
timedOut = true;
} catch (InterruptedException retry) {
// 如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
timedOut = false;
}
}
}
这里重要的地方是第二个if判断，目的是控制线程池的有效线程数量。由上文中的分析可以知道，在执行execute方法时，如果当前线程池的线程数量超过了corePoolSize且小于maximumPoolSize，并且workQueue已满时，则可以增加工作线程，但这时如果超时没有获取到任务，也就是timedOut为true的情况，说明workQueue已经为空了，也就说明了当前线程池中不需要那么多线程来执行任务了，可以把多于corePoolSize数量的线程销毁掉，保持线程数量在corePoolSize即可。
什么时候会销毁？当然是runWorker方法执行完之后，也就是Worker中的run方法执行完，由JVM自动回收。
getTask方法返回null时，在runWorker方法中会跳出while循环，然后会执行processWorkerExit方法。
processWorkerExit方法：
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
// 如果线程执行时没有出现异常，说明在getTask()方法中已经已经对workerCount进行了减1操作，这里就不必再减了。
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//统计完成的任务数
completedTaskCount += w.completedTasks;
// 从workers中移除，也就表示着从线程池中移除了一个工作线程
workers.remove(w);
} finally {
mainLock.unlock();
}
// 根据线程池状态进行判断是否结束线程池
tryTerminate();
int c = ctl.get();
/*
* 当线程池是RUNNING或SHUTDOWN状态时，如果worker是异常结束，那么会直接addWorker；
* 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个worker；
* 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSize。
*/
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
至此，processWorkerExit执行完之后，工作线程被销毁，以上就是整个工作线程的生命周期，从execute方法开始，Worker使用ThreadFactory创建新的工作线程，runWorker通过getTask获取任务，然后执行任务，如果getTask返回null，进入processWorkerExit方法，整个线程结束，如图所示：
ScheduledThreadPoolExecutor：
- schedule：延迟多长时间之后只执行一次；
- scheduledAtFixedRate固定：延迟指定时间后执行一次，之后按照固定的时长周期执行；
- scheduledWithFixedDelay非固定：延迟指定时间后执行一次，之后按照：上一次任务执行时长 + 周期的时长 的时间去周期执行；
private void delayedExecute(RunnableScheduledFuture<?> task) {
//如果线程池不是RUNNING状态，则使用拒绝策略把提交任务拒绝掉
if (isShutdown())
reject(task);
else {
//与ThreadPoolExecutor不同，这里直接把任务加入延迟队列
super.getQueue().add(task);
//如果当前状态无法执行任务，则取消
if (isShutdown() &&
!canRunInCurrentRunState(task.isPeriodic()) &&
remove(task))
task.cancel(false);
else
//和ThreadPoolExecutor不一样，corePoolSize没有达到会增加Worker;
//增加Worker，确保提交的任务能够被执行
ensurePrestart();
}
offer方法：
public boolean offer(Runnable x) {
if (x == null)
throw new NullPointerException();
RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
final ReentrantLock lock = this.lock;
lock.lock();
try {
int i = size;
if (i >= queue.length)
// 容量扩增50%。
grow();
size = i + 1;
// 第一个元素,其实这里也可以统一进行sift-up操作,没必要特判。
if (i == 0) {
queue[0] = e;
setIndex(e, 0);
} else {
// 插入堆尾。
siftUp(i, e);
}
// 如果新加入的元素成为了堆顶,则原先的leader就无效了。
if (queue[0] == e) {
leader = null;
// 由于原先leader已经无效被设置为null了,这里随便唤醒一个线程(未必是原先的leader)来取走堆顶任务。
available.signal();
}
} finally {
lock.unlock();
}
return true;
siftup方法：
private void siftUp(int k, RunnableScheduledFuture<?> key) {
// 找到父节点的索引
while (k > 0) {
// 获取父节点
int parent = (k - 1) >>> 1;
RunnableScheduledFuture<?> e = queue[parent];
// 如果key节点的执行时间大于父节点的执行时间，不需要再排序了
if (key.compareTo(e) >= 0)
break;
// 如果key.compareTo(e) < 0，
说明key节点的执行时间小于父节点的执行时间，需要把父节点移到后面
queue[k] = e;
setIndex(e, k);
// 设置索引为k
k = parent;
}
// key设置为排序后的位置中
queue[k] = key;
setIndex(key, k);
任务执行：
public void run() {
// 是否周期性，就是判断period是否为0。
boolean periodic = isPeriodic();
// 检查任务是否可以被执行。
if (!canRunInCurrentRunState(periodic))
cancel(false);
// 如果非周期性任务直接调用run运行即可。
else if (!periodic)
ScheduledFutureTask.super.run();
// 如果成功runAndRest，则设置下次运行时间并调用reExecutePeriodic。
else if (ScheduledFutureTask.super.runAndReset()) {
setNextRunTime();
// 需要重新将任务(outerTask)放到工作队列中。此方法源码会在后文介绍ScheduledThreadPoolExecutor本身API时提及。
reExecutePeriodic(outerTask);
}
fied-rate模式和fixed-delay模式区别
private void setNextRunTime() {
long p = period;
/*
* fixed-rate模式，时间设置为上一次时间+p。
* 提一句，这里的时间其实只是可以被执行的最小时间，不代表到点就要执行。
* 如果这次任务还没执行完是肯定不会执行下一次的。
*/
if (p > 0)
time += p;
/**
* fixed-delay模式，计算下一次任务可以被执行的时间。
* 简单来说差不多就是当前时间+delay值。因为代码走到这里任务就已经结束了,now()可以认为就是任务结束时间。
*/
else
time = triggerTime(-p);
}
long triggerTime(long delay) {
/*
* 如果delay < Long.Max_VALUE/2,则下次执行时间为当前时间+delay。
*
* 否则为了避免队列中出现由于溢出导致的排序紊乱,需要调用overflowFree来修正一下delay(如果有必要的话)。
*/
return now() + ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
}
/**
* 主要就是有这么一种情况：
* 某个任务的delay为负数，说明当前可以执行(其实早该执行了)。
* 工作队列中维护任务顺序是基于compareTo的，在compareTo中比较两个任务的顺序会用time相减，负数则说明优先级高。
*
* 那么就有可能出现一个delay为正数,减去另一个为负数的delay，结果上溢为负数，则会导致compareTo产生错误的结果。
*
* 为了特殊处理这种情况，首先判断一下队首的delay是不是负数，如果是正数不用管了,怎么减都不会溢出。
* 否则可以拿当前delay减去队首的delay来比较看，如果不出现上溢，则整个队列都ok，排序不会乱。
* 不然就把当前delay值给调整为Long.MAX_VALUE + 队首delay。
*/
private long overflowFree(long delay) {
Delayed head = (Delayed) super.getQueue().peek();
if (head != null) {
long headDelay = head.getDelay(NANOSECONDS);
if (headDelay < 0 && (delay - headDelay < 0))
delay = Long.MAX_VALUE + headDelay;
}
return delay;
循环的根据key节点与它的父节点来判断，如果key节点的执行时间小于父节点，则将两个节点交换，使执行时间靠前的节点排列在队列的前面。
可以理解为一个树形的结构，最小点堆的结构；父节点一定小于子节点；
DelayQueue内部封装了一个PriorityQueue，它会根据time的先后时间排序（time小的排在前面），若time相同则根据sequenceNumber排序（ sequenceNumber小的排在前面）；
线程池应用之如何合理配置线程数
一、线程池如何配置合理线程数
（1）CPU密集型：
定义：CPU密集型的意思就是该任务需要大量运算，而没有阻塞，CPU一直全速运行。
CPU密集型任务只有在真正的多核CPU上才可能得到加速（通过多线程）。
CPU密集型任务配置尽可能少的线程数。
CPU密集型线程数配置公式：(CPU核数+1)个线程的线程池
（2）IO密集型：
定义：IO密集型，即该任务需要大量的IO，即大量的阻塞。
在单线程上运行IO密集型任务会导致浪费大量的CPU运算能力浪费在等待。
所以IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要利用了被浪费掉的阻塞时间。
第一种配置方式：
由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程。
配置公式：CPU核数 * 2。
第二种配置方式：
IO密集型时，大部分线程都阻塞，故需要多配置线程数。
配置公式：CPU核数 / (1 – 阻塞系数)（0.8~0.9之间）
比如：8核 / (1 – 0.9) = 80个线程数
cpu核心数 逻辑核心
//cpu核心数 逻辑核心
int availableProcessors = Runtime.getRuntime().availableProcessors();
