1、线程池引入原因：
在Java中通过线程池复用线程
2、线程池类图：
3、线程池核心类介绍：
3.1
在ThreadPoolExecutor类中提供了四个构造方法：
public class ThreadPoolExecutor extends AbstractExecutorService {
.....
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
...
}
3.2 构造器中各个参数含义：
corePoolSize：核心池的大小
默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中
maximumPoolSize：
线程池最大线程数
keepAliveTime：
表示线程没有任务执行时最多保持多久时间会终止
默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize
unit：
参数keepAliveTime的时间单位，七种取值
TimeUnit.DAYS;
//天
TimeUnit.HOURS;
//小时
TimeUnit.MINUTES;
//分钟
TimeUnit.SECONDS;
//秒
TimeUnit.MILLISECONDS;
//毫秒
TimeUnit.MICROSECONDS;
//微妙
TimeUnit.NANOSECONDS;
//纳秒
workQueue：
阻塞队列，用来存储等待执行的任务
有三种：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
后两种常用
threadFactory：
线程工厂，主要用来创建线程
handler：
表示当拒绝处理任务时的策略
有四种策略
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
4、线程池实现原理
4.
1.线程池状态
4.
2.任务的执行
4.
3.
任务缓存队列及排队策略
4.
1.线程池状态
volatile
int
runState;
static
final
int
RUNNING =
0
;
static
final
int
SHUTDOWN =
1
;
static
final
int
STOP =
2
;
static
final
int
TERMINATED =
3
;
runState表示当前线程池的状态，它是一个volatile变量用来保证线程之间的可见性；
初始时，线程池处于RUNNING状态
调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕
调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务
当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态
4.
2.任务的执行
先来看一下ThreadPoolExecutor类中其他的一些比较重要成员变量
private
final
BlockingQueue<Runnable> workQueue;
//任务缓存队列，用来存放等待执行的任务
private
final
ReentrantLock mainLock =
new
ReentrantLock();
//线程池的主要状态锁，对线程池状态（比如线程池大小
//、runState等）的改变都要使用这个锁
private
final
HashSet<Worker> workers =
new
HashSet<Worker>();
//用来存放工作集
private
volatile
long
keepAliveTime;
//线程存活时间
private
volatile
boolean
allowCoreThreadTimeOut;
//是否允许为核心线程设置存活时间
private
volatile
int
corePoolSize;
//核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private
volatile
int
maximumPoolSize;
//线程池最大能容忍的线程数
private
volatile
int
poolSize;
//线程池中当前的线程数
private
volatile
RejectedExecutionHandler handler;
//任务拒绝策略
private
volatile
ThreadFactory threadFactory;
//线程工厂，用来创建线程
private
int
largestPoolSize;
//用来记录线程池中曾经出现过的最大线程数
private
long
completedTaskCount;
//用来记录已经执行完毕的任务个数
在ThreadPoolExecutor类中,
execute()方法
的实现原理
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
方法执行流程
：
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 ||
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
}
}
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()) // 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) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
方法执行流程：
4.3.
任务缓存队列及排队策略
LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
synchronousQueue：
生产者线程对其的插入操作put必须等待消费者的移除操作take，反过来也一样
。