前言
过程和线程的关系置信大家都晓得，这里我就不做过多的解释了，既然一个过程是由多个线程组成的，那么线程池又是由若干个线程队列组成的，在并发量比拟高的情景下，咱们通常会去创立线程池就执行工作，而不繁多的创立多个线程去执行工作，因为线程的创立的一系列动作，是须要资源开销的，如果频繁的对线程创立销毁，其实自身是一种很浪费资源的，就更谈不上提高效率了。
个别都会创立线程池将线程对立治理，并且还会引入阻塞和非阻塞队列，接管须要排队解决的工作，然而线程池里的线程是在解决完工作就会进行销毁么，其实并不是这样的，上面咱们一起来对线程池里线程是如何复用的进行剖析。
应用线程池
应用线程池起因
1. 复用已创立的线程，缩小线程创立、销毁开销。
2. 能够依据本身零碎的承载能力，正当对线程池线程数量进行管制。
3. 管制并发数，爱护零碎。
private static void creatThreadPool() throws InterruptedException {
List<Thread> threadList = new ArrayList<>();
long start = System.currentTimeMillis();
log.info("创立线程池开始");
for (int i = 0; i < 100; i++) {Thread thread = new Thread(() -> {
try {TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {e.printStackTrace();
}
}, "thread" + i);
thread.start();
threadList.add(thread);
TimeUnit.MILLISECONDS.sleep(1);
}
long end = System.currentTimeMillis();
long needTime = end - start;
log.info("创立 100 个线程所破费的工夫：" + needTime + "ms");
}
public static void main(String[] args) throws InterruptedException {
creatThreadPool();}
复制代码
创立 100 个线程须要 264ms，均匀一个线程的创立须要 2.2ms 左右，线程执行工作能够只须要不到 1ms，那么这样看来创立线程是不划算的。
这里除里 JDK 自带的四种线程池类型，简略介绍下 jdk 自带四种线程池。
1.newCachedThreadPool：可缓存的的无界限程池，能够自动线程回收，通常执行短期异步的工作。
2.newFixThreadPool：固定数量的线程池，管制并发数。
3.newSingleThreadPool：单线程工作的线程池，所有工作依照 FIFO 先进先出的准则执行。
4.newScheduleThreadPool：可定期执行的线程池，可指定执行工夫和执行次数。
通常状况下，在阿里的开发手册上写不举荐应用 Executors 创立线程，也就是线程池的顶级接口，jdk 自带的线程池创立的时候是没有外围线程数的，一直的创建对象，那么就会存在内存溢出的危险。
线程池的工作流程
个别创立线程池还是应用 ThreadPoolExecutor 创立，它的上接口是 ExecutorService，所有说真正创立线程池是用 ExecutorService 创立。
7 大外围参数这里就不多说了，间接说线程池的工作流程。
1. 首先当运行的线程池 <corePoolSize（外围线程数），就会创立线程执行这个工作
2. 线程池线程数 > corePoolSize（外围线程数），工作放入队列。
3. 队列已满，以后运行的线程数 <MaxImumPoolSize（最大线程数），创立非核心线程数执行工作，如果运行的线程数 > MaxImumPoolSize（最大线程数），应用 Handler 回绝策略，当然不能抛弃工作，个别应用 CallerRunsPolicy 应用调用线程执行工作。
4. 以后线程不须要执行工作，也不能让它始终存在着占用资源，超出 keepAliveTime，运行线程数 > corePoolSize，这线程会被回收掉，这样做次要是管制外围线程里线程数量。
线程复用
首先看 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);
}复制代码
这里看到每个 if 判断里都存在 addWorker 办法，那么这个办法必定是线程是否复用的重点，
Worker w = null;
try {
// 将工作放到 Worker 工作线程外面，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();
//hashset 汇合里寄存 Worker 对象
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;
复制代码
Worker 是个 final 润饰的外部类，意味着不能被其余类继承，那么线程复用只能在这一个类外面进行，接着看 Worker 的 run 办法外面执行的 runWorker 办法，这个是线程复用的外围办法。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();// 获取线程外面执行的工作
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 如果工作不为空 || 从新拿取线程里的工作
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
// 判断线程的状态，并执行对应的回绝策略
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {beforeExecute(wt, task);
Throwable thrown = null;
try {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;
w.completedTasks++;
w.unlock();}
}
completedAbruptly = false;
} finally {processWorkerExit(w, completedAbruptly);
}
复制代码
getTask 办法从新拿取线程里的工作，后面一系列的判断次要是来查看线程的状态，以及线程池线程的数量，其外围次要是线程数量是否超过了外围线程数，如果超过了则会进入 workQueue 工作队列，workQueue.poll 非核心线程会始终去工作队列里获取工作，非核心线程曾经满了，则会 workQueue.take() 外围线程去获取工作，后面的 runWorker 办法是有 while 循环的，这样就会始终执行上来，循环拿取工作，如果这个时候工作队列外面没有队列，超过 keepAliveTime 线程存活工夫还没有拿到工作，则会对对应线程进行销毁。
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);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {timedOut = false;}
}}
复制代码
总结
在日常开发中，对线程池的优化也是比拟重要的，如果线程池的外围线程数和最大线程数都不是随便定义的，还是要联合自身服务器 cpu 的状况，以及阻塞队列的应用，在肯定状况下能缓解线程的压力，自身阻塞队列是带有阻塞和唤醒的性能，阻塞队列的长度也是须要依据理论开大的业务场景去定义的，最初使用好线程池，在解决高并发的业务场景下还是尤为要害的一项技术。