这篇文章在讲什么

这篇文章会带你从基础开始理解 Java 线程池。

读完后你会明白：

为什么需要线程池？直接 new Thread 不行吗？各自的作用，各自适用什么场景？Spring 中怎么使用线程池？生产环境中线程池应该怎么配置？面试中高频问题怎么回答，

在开始之前，先问你几个问题

至于问题1。如果一个程序每秒有 10000 个请求，每个请求需要并发处理，你能每个请求都 new Thread 吗？会有什么问题，关系？再看问题3，corePoolSize 和 maximumPoolSize 都是 5。队列满了之后会怎样，如果 corePoolSize 是 3。maximumPoolSize 是 8，队列满了之后又会怎样？线程池，为什么生产环境不推荐用默认的？

带着这些问题往下读。

第一部分的观点是，为什么需要线程池

一、从一个最简单的并发场景开始

假设你有一个 Web 接口。每个请求需要查询三个远程服务：

// 串行执行：一个一个查，总耗时 = a + b + c = a1000ms
public OrderDetail getOrderDetail {
Order order = orderService.query;// a300ms
User user = userService.query);不过，// b200ms
List items = itemService.query;// c500ms
return new OrderDetail;}

如果改成并发执行：

// 并发执行：三个同时查，总耗时 = max = c500ms
public OrderDetail getOrderDetail {
Future orderFuture = executor.submit -> orderService.query);Future userFuture = executor.submit -> userService.query));Future itemsFuture = executor.submit -> itemService.query);Order order = orderFuture.get;
User user = userFuture.get;List items = itemsFuture.get;return new OrderDetail;话说回来，}

耗时从 a1000ms 落到 c5a ms。这里的 executor就是线程池。按理说，

二、为什么不直接 new Thread？

// 最原始的方式：每个任务创建一个线程
new Thread -> orderService.query).start;new Thread -> userService.query).start;new Thread -> itemService.query).start;

看起来能用，但生产环境完全不行。从问题有三个来看，

至于问题一。创建和销毁线程的开销很大

. 在 JVM 中分配内存 . 在操作程序内核中创建线 . 上下文切换的准备工作销毁一个线 (b需要做什么： .释放 JVM 内存 .通知操作程序回收资源这些操作耗时大约在 .a ms ~ ams之间。听起来不多，算一笔账：

假设你程序每秒处理a1万请求 每条请求创建a条新条件 每秒创建a万条新条件创建开销:×.am s=aam m s 每条新条件 am MB堆栈空间:×amMB=acGB内存而且这些新条件执行完就销毁了 下次请求又重新创建。

大量时间花在了创建和销毁新条件上 不执领域务逻辑。

至于问题二，无法控制并发数量

// 假设突然来了 a1万个请 求for {newThread -> doSomething ) . start;//瞬间创造 a万条新 新 ) } 

 a万次×amMB堆栈空间= ac GB 内存 操作程序可以创造很多新超过限制→ OutOfMemoryError:unable to create new native thread服务器直接崩溃 

problem three :没有统一管理

 line creation is completed and not managed Do not know how many lines are running Do not know which tasks are in queue Cannot shut down gracefully Cannot monitor line status 

three :thread pool thought :reuse threads

 The core idea of thread pool :not every task creates a thread but creates several threads in advance puts m in one “pool”。怎么说呢，Has task comes from pool Take one thread to execute。Execution after completion does not destroy thread Put back in pool wait for next task。Like restaurant waiters : Not hire waiter temporarily for each customer but hire some waiters in advance Send m over when needed When customers come Send over any waiter who is available When no one is available Wait until re is an available waiter Then send him over to serve customers 

 No thread pool :
Request → Create line A → Execute → Destroy line A Request → Create line B → Execute → Destroy line B Request → Create line C → Execute → Destroy line C
With thread pools :
Start-up time → Create lines A,B。C and put m in pool Request → Take out line A → Execute → Line A returns to pool Request → Take out line A again→ Execute again→ Line A returns to pool again Request → Take out line B and execute it n return it back to pool again
The result:
Lines are reused Creation and destruction overheads only occur once .

second part : core parameters of thread pools

one :look at creating thread pools first

ThreadPoolExecutorexecutor=newThreadPoolExecutor(
TimeUnit.SECONDS,newArrayBlockingQueue <>,newThreadFactory{...},newThreadPoolExecutor.AbortPolicy
);

---