java 线程池（线程的复用）
一. 线程池简介
1. 线程池的概念：
线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。
2. 线程池的工作机制
2.1 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
2.1 一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。
3. 使用线程池的好处
Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处：
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。
二：JDK对线程池的支持
JDK提供的Executor框架
JDK提供了Executor框架，可以让我们有效的管理和控制我们的线程，其实质也就是一个线程池。Executor下的接口和类继承关系如下：
Executors：提供了一系列静态工厂方法用于创建各种线程池
其中常用几类如下：
public static ExecutorService newFixedThreadPool() public static ExecutorService newSingleThreadExecutor() public static ExecutorService newCachedThreadPool() public static ScheduledExecutorService newSingleThreadScheduledExecutor() public static ScheduledExecutorService newScheduledThreadPool()
1、newFixedThreadPool：该方法返回一个固定线程数量的线程池；
2、newSingleThreadExecutor：该方法返回一个只有一个现成的线程池；
3、newCachedThreadPool：返回一个可以根据实际情况调整线程数量的线程池；
4、newSingleThreadScheduledExecutor：该方法和newSingleThreadExecutor的区别是给定了时间执行某任务的功能，可以进行定时执行等；
5、newScheduledThreadPool：在4的基础上可以指定线程数量。
创建线程池实质调用的还是ThreadPoolExecutor
在Executors类中，我们拿出来一个方法简单分析一下：
可以看出，类似的其他方法一样，在Executors内部创建线程池的时候，实际创建的都是一个ThreadPoolExecutor对象，只是对ThreadPoolExecutor构造方法，进行了默认值的设定。ThreadPoolExecutor的构造方法如下：
参数含义如下：
1、corePoolSize 核心线程池大小；
2、maximumPoolSize 线程池最大容量大小；
3、keepAliveTime 线程池空闲时，线程存活的时间；
4、TimeUnit 时间单位；
5、ThreadFactory 线程工厂；
6、BlockingQueue任务队列；
7、RejectedExecutionHandler 线程拒绝策略；
Executor框架实例
1、实例一：
public class ThreadPoolDemo { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(4); for (int i = 0; i < 10; i++) { int index = i; executorService.submit(() -> System.out.println("i:" + index + " executorService")); } executorService.shutdown(); } }
submit(Runnable task)方法提交一个线程。
但是使用最新的“阿里巴巴编码规范插件”检测一下会发现：
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，
这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors各个方法的弊端：
1）newFixedThreadPool和newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
2）newCachedThreadPool和newScheduledThreadPool:
主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
2、实例二：
遵循阿里巴巴编码规范的提示，示例如下：
public class ThreadPoolDemo { public static void main(String[] args) { ExecutorService executorService = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 10; i++) { int index = i; executorService.submit(() -> System.out.println("i:" + index + " executorService")); } executorService.shutdown(); } }
或者这样：
public class ThreadPoolDemo { public static void main(String[] args) { ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 10; i++) { int index = i; pool.submit(() -> System.out.println("i:" + index + " executorService")); } pool.shutdown(); } }
3、实例三：
自定义ThreadFactory、自定义线程拒绝策略
public static void main(String[] args) { ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10), new ThreadFactory() { //自定义ThreadFactory @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r); thread.setName(r.getClass().getName()); return thread; } }, new ThreadPoolExecutor.AbortPolicy()); //自定义线程拒绝策略 for (int i = 0; i < 10; i++) { int index = i; executorService.submit(() -> System.out.println("i:" + index)); } executorService.shutdown(); } }
使用submit的坑
首先看一下实例：
public class ThreadPoolDemo3 { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(4); for (int i = 0; i < 5; i++) { int index = i; executorService.submit(() -> divTask(100, index)); } executorService.shutdown(); }
private static void divTask(int a, int b) { double result = a / b; System.out.println(result); } }
运行结果：
上述代码，可以看出运行结果为4个，因该是有5个的，但是当i=0的时候，100/0是会报错的，但是日志信息中没有任何信息，是为什么那？如果使用了submit(Runnable task) 就会出现这种情况，任何的错误信息都出现不了！
这是因为使用submit(Runnable task) 的时候，错误的堆栈信息跑出来的时候会被内部捕获到，所以打印不出来具体的信息让我们查看，解决的方法有如下两种：
1、使用execute（）代替submit（）；
public class ThreadPoolDemo3 { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(4); for (int i = 0; i < 5; i++) { int index = i; executorService.execute(() -> divTask(100, index)); } executorService.shutdown(); } private static void divTask(int a, int b) { double result = a / b; System.out.println(result); } }
运行结果：
2、使用Future
public class ThreadPoolDemo3 { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(4); for (int i = 0; i < 5; i++) { int index = i; Future future = executorService.submit(() -> divTask(200, index)); try { future.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } executorService.shutdown(); } private static void divTask(int a, int b) { double result = a / b; System.out.println(result); } }
运行结果：
3、execute和submit的区别
（1）execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。通过以下代码可知execute()方法输入的任务是一个Runnable类的实例。
（2）submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
思考：线程池中的工作线程是如何实现线程复用的？
一个线程一般在执行完任务后就结束了，怎么再让他执行下一个任务呢？
线程重用的核心是，我们知道，Thread.start()只能调用一次，一旦这个调用结束，则该线程就到了stop状态，不能再次调用start。
则要达到复用的目的，则必须从Runnable接口的run()方法上入手，可以这样设计这个Runnable.run()方法（就叫外面的run()方法）：
它本质上是个无限循环，跑的过程中不断检查我们是否有新加入的子Runnable对象（就叫内部的runnable:run()吧，它就是用来实现我们自己的任务），有就调一下我们的run()，其实就一个大run()把其它小run()#1,run()#2,...给串联起来了，基本原理就这么简单
不停地处理我们提交的Runnable任务。
则要达到复用的目的，则必须从Runnable接口的run()方法上入手，可以这样设计这个Runnable.run()方法（就叫外面的run()方法）：
它本质上是个无限循环，跑的过程中不断检查我们是否有新加入的子Runnable对象（就叫内部的runnable:run()吧，它就是用来实现我们自己的任务），有就调一下我们的run()，其实就一个大run()把其它小run()#1,run()#2,...给串联起来了，基本原理就这么简单
不停地处理我们提交的Runnable任务。
public void run() {
while(true) {
if(tasks available) {
Runnable task = taskqueue.dequeue();
task.run();
} else {
// wait or whatever
}
}
}
下面举个代码实例来模拟实现线程池复用线程
生产了两个 线程作为工人
生产了10个同样的任务，让他们执行
利用复用让 2个线程完成10个任务
import java.util.ArrayList; import java.util.LinkedList; import java.util.concurrent.TimeUnit; public class Mythreadpool { LinkedList<Task> taskList = new LinkedList<Task>(); class Task { //任务类 int id; Task(int id){ this.id=id; System.out.println("第"+id+"个任务产生"); } public void run() {//具体的工作 System.out.println("第"+id+"个任务正在执行"); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("第"+id+"个任务执行完毕"); } } class Worker extends Thread { //工人实体 String name; Worker(String name) { this.name = name; } public void run() { while(true) { if(taskList.size() == 0) { try { synchronized (taskList) { System.out.println("Worker " + name+" 没有任务"); taskList.wait(); //没得到任务，进入tasklist的等待队列 } } catch (InterruptedException e) { e.printStackTrace(); } } synchronized (taskList) { System.out.println("Worker " + name+" 得到任务"); taskList.removeFirst().run(); } } } } void pool() { //工人。只生产了两个工人 ArrayList<Worker> wokerlist=new ArrayList<Worker>(); for(int i=0;i<2;i++) { Worker k = new Worker("第"+(i+1)+"个工人"); k.start(); wokerlist.add(k);// } } class Factory extends Thread{ //生产任务的线程，总共会生产10个任务 public void run() { for(int i=0;i<10;i++) { synchronized(taskList) { taskList.addLast(new Task(i+1)); taskList.notify(); } try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } } public static void main(String[] args) { Mythreadpool mythreadpool = new Mythreadpool(); mythreadpool.pool(); //初始化工人 Mythreadpool.Factory m= mythreadpool.new Factory(); m.start(); } }
执行效果：
分析jdk中是如何实现线程复用的
线程复用
即，如何将放入线程中的诸多任务，在N个线程中执行的。
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); }
分析：可以看出：ThreadPoolExecutor.execute()的功能就是：
1、将任务添加至阻塞队列workQueue，workQueue.offer(command)
2、根据core和maxPool，选择是否创建Worker，addWorker()
因此，线程复用的实现应该在worker中，打开addWorker()方法观察
addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
//创建worker
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
}
}
//启动worker
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//ThreadExecutor的全局锁，在创建\销毁worker工作池的时候，才会用到
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;
}
分析：addworker分为两部分：1、创建worker，2、启动worker
规则校验：
与core和maxPool数量的规则相同
创建worker：
获取ThreadLocal的全局锁。 安全的创建Worker。
t.start();
因此：重点又回到了Worker的run方法上
Worker.run()
public void run() {
runWorker(this);
}
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);
}
}
分析：这里就比较清晰了：
1、通过getTask()方法，获取待执行的任务。
2、通过task.run();执行具体的任务。
3、正常情况，只有当所有任务执行完毕才会停止运行。
因此：
1、进一步分析getTask()
2、执行task.run()方法。-->>这里可以看出，事实上线程在执行任务的时候，本质上是调用了任务自身的run/call方法。
==》》有点像是thread.get(threadlocal) 本质上是调用了 threadlocalMap.get(thread) 的感觉
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);
// 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;
}
}
}
分析：也不用把代码完全细节完全深究，可以发现方法是从workQueue中获取task的，所以最终的问题就是看这个变量workQueue是谁的成员变量。
public class ThreadPoolExecutor extends AbstractExecutorService {
private final BlockingQueue<Runnable> workQueue;
。。。
}
分析，getTask是从线程池中，获取的任务。即所有的任务都放在ThreadPoolExecutor中，线程池启动多个Worker去执行任务，每个worker不停的从ThreadPoolExector的workQueue中取出任务，比你高执行task.run()方法，直至所有的任务执行完毕。
至此分析完毕。
资料出处：
https://blog.csdn.net/yinni11/article/details/81348210
https://www.jianshu.com/p/93c26498a3c5
https://blog.csdn.net/qq_38966984/article/details/80415736
