由于线程的频繁调度，而影响性能，通过线程池来维护，减少线程的频繁的创建和销毁。
在Executors统一管理，看一下常见的四中线程池：
1.newFixedThreadPool：创建定长的线程池，超出定长在线程队列中等待。
```
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
```
2.newCachedThreadPool：线程数无限大，当线程队列中有空闲线程时会复用，否则重新创建线程，同时线程60s没有用时，从线程队列中移除。
```
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
```
3.newScheduledThreadPool：次线程池是在规定的时间进行调度。
```
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
```
4.newSingleThreadExecutor：仅有一个线程在调度，且有顺序的进行出队和入队。
```
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
```
但是他们都调用了ThreadPoolExecutor：看一下核心构造器里的几个参数
corePoolSize： 要保留在池中的线程数量。
maximumPoolSize：线程池中允许的最大线程数。
keepAliveTime：空闲线程等待的最大时间。
unit：keepAliveTime的时间单位。
workQueue：可执行的任务队列。
threadFactory：执行创建一个新的线程时使用。
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.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
```
线程池中常用几个方法源码：
看一下runState控制得几种状态：
```
RUNNING: 接受新任务并能够对添加的任务处理。
SHUTDOWN: 不接受新任务，但能处理已在队列中的任务。
STOP: 不接受新任务，不处理排队的任务，并同时中断正在进行的任务。
TIDYING: 所有任务全部中断，同时将workerCount 置0，并将所有线程切换到TIDYING状态，会执行钩子函数terminated()。
TERMINATED: 表示线程池彻底终止。执行完terminated()之后，就会由 TIDYING -> TERMINATED。
```
线程池的几种转态转换：
```
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();//保证了数据的原子性，不被其他线程干扰
if (workerCountOf(c) < corePoolSize) {//运行的线程数小于corePoolSize的数量时
if (addWorker(command, true))//添加一个新的到任务中
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {//插入任务成功且是Running状态下
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))//移除任务成功且不是Running状态下
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//如果添加到任务中失败，抛出异常。
else if (!addWorker(command, false))
reject(command);
}
```
这里addWorker(Runnable firstTask, boolean core)中的两个参数：
firstTask：新线程首要运行。
core：用一个布尔值判断当前线程数是否小于corePoolSize或maximumPoolSize。在源码中
```
wc >= (core ? corePoolSize : maximumPoolSize))
```
shutdown()方法:对以前的任务切换到SHUTDOWN状态，不接受新的任务。
```
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;//重入锁
mainLock.lock();
try {
checkShutdownAccess();//判断调用者是否有权限shutdown线程池
advanceRunState(SHUTDOWN);//线程池状态切换为SHUTDOWN
interruptIdleWorkers();//中断可能正在等待任务的线程
onShutdown(); // SHUTDOWN转态下的进一步清理。但是使用了ScheduledThreadPoolExecutor取消延迟的任务。
} finally {
mainLock.unlock();
}
tryTerminate();//试着终止线程池
}
```
更多文章：https://blog.csdn.net/qq_34447328
