Java并发编程（5）

多好听 發表於 2025-10-2 21:52:00

<hr>
<h1 style="text-align: center">线程池</h1>
<h1>1、什么是线程池？</h1>
<ul>
<li>管理线程，避免增加创建线程和销毁线程的资源消耗：线程也是一个对象，创建一个对象要类加载，销毁一个对象要走GC垃圾回收流程，都是有资源开销的。</li>
<li>提高响应速度：对比普通的做法，是重新创建一个线程执行，要慢很多。</li>
<li>重复利用：线程用完再放回池子，可以达到重复利用的效果，节省资源。</li>
</ul>
<h1>2、说说工作中线程池的应用</h1>
 　　可以讲在拼团中怎么用的。
<h1>3、说一下线程池的工作流程</h1>
<ul>
<li> 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的（因为可以选择）。</li>
<li>当调用excute()方法添加一个任务时，线程池会做如下判断：
<ul>
<li>若正在运行的线程数量小于corePoolSize，则马上创建线程运行这个任务。</li>
<li>若正在运行的线程数量大于或等于corePoolSize，则将这个任务放入队列。</li>
<li>若这时队列满了，而且正在运行的线程数量小于maximumPoolSize，那么还是要创建非核心线程立刻执行这个任务。</li>
<li>若队列满了，且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会根据拒绝策略来应对处理。</li>
</ul>
</li>
<li>当一个线程完成任务时，它会从队列中取下一个任务来执行。</li>
<li>当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，若当前正在运行的线程数大于corePoolSize，那么这个线程会被停掉。所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。</li>
</ul>
<blockquote>
为什么不直接填满到maximyumPoolSize：
<ul>
<li>内存占用大、上下文切换频繁消耗CPU、同步开销大。</li>
<li>动态扩展的方案只在高峰期临时创建更多线程，是一种“按需分配”的原则：先用少量核心线程处理常规负载，队列缓冲短期突发请求，实在处理不过来才会额外创建线程，空闲时回收多余线程。是为了在响应速度和资源效率之间取得最佳平衡。</li>
</ul>
</blockquote>
<h1>4、线程池主要参数有哪些？</h1>
<ul>
<li>corePoolSize：初始化线程池中核心线程数，当线程池中线程数小于corePoolSize时，系统默认是添加一个任务才从创建一个线程。</li>
<li>maximumPoolSize：表示允许的最大线程数 = 非核心线程数+ 核心线程数。当工作队列也满了，但线程池中总线程数<maximumPoolSize时就会再次创建新的线程。</li>
<li>keepAliveTime：非核心线程闲置下来不干活最多存活时间。</li>
<li>unit：非核心线程保持存活的时间的单位。
<ul>
<li>
<div>TimeUnit.DAYS; 天</div>
<div>TimeUnit.HOURS; ⼩时</div>
<div>TimeUnit.MINUTES; 分钟</div>
<div>TimeUnit.SECONDS; 秒</div>
<div>TimeUnit.MILLISECONDS; 毫秒</div>
<div>TimeUnit.MICROSECONDS; 微秒</div>
<div>TimeUnit.NANOSECONDS; 纳秒</div>
</li>
</ul>
</li>
<li>workQueue：线程池等待队列</li>
</ul>
<blockquote><ol>
<li>ArrayBlockingQueue：有界队列是一个用数组实现的有界阻塞队列，按FIFO排序量。</li>
<li>LinkedBlockingQueue：基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置的话就是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE，吞吐量通常要高于ArrayBlockingQueue；newFixedThreadPool线程池用了这个队列。</li>
<li>DelayQueue：延迟队列是一个任务定时周期的执行的队列。单纯的DealyDueue不保证相同延迟任务的FIFO，但ScheduledThreadPoolExecutor通过添加序列号的方式，确保了FIFO顺序。（任务1还有2秒执行，任务2还有3秒执行，那么任务1排在任务2前面）
<ul>
<li><code>getDelay()</code>返回距离触发还有多久</li>
<li>当<code>getDelay() <= 0</code>时，任务才可被取出</li>
<li data-spm-anchor-id="5176.28103460.0.i11.2f2e2e311GVuEr">队列按触发时间排序，最早该执行的任务在队首</li>
</ul>
</li>
<li>priorityBlockingQueue：是具有优先级的无界阻塞队列。</li>
<li>SynchronousQueue：是一个不存储元素的阻塞队列，每个插入操作必须等另一个线程调用移除操作，否则插入操作一直处于阻塞，吞吐量通常高于
<div>LinkedBlockingQuene（因为是生产者直接交给消费者，无缓冲，适合突发性、短时任务），newCachedThreadPool线程池使⽤了这个队列。</div>
</li>
</ol></blockquote>
<ul>
<li>threadFactory：创建一个新线程时用的工厂，可以用来设定线程名、是否为daemon线程等。</li>
</ul>
 
<div class="cnblogs_Highlighter">
<pre class="brush:java;gutter:true;">// 1. 默认工厂（抽象但可用）
ThreadFactory defaultFactory = Executors.defaultThreadFactory();

// 2. 自定义工厂 - 可以完全控制线程创建过程
ThreadFactory customFactory = new ThreadFactory() {
private final AtomicInteger threadNumber = new AtomicInteger(1);

@Override
public Thread newThread(Runnable r) {
 Thread t = new Thread(r);
 t.setName("my-pool-worker-" + threadNumber.getAndIncrement());
 t.setDaemon(false); // 设置为非守护线程
 t.setPriority(Thread.NORM_PRIORITY); // 设置优先级
 return t;
}
};

// 3. 在线程池中使用
ThreadPoolExecutor pool = new ThreadPoolExecutor(
CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE,
60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(),
customFactory, // 这里传入自定义工厂
new ThreadPoolExecutor.CallerRunsPolicy()
);</pre>
</div>
<ul>
<li>handler：拒绝策略。</li>
</ul>
<blockquote><ol>
<li>AbortPolicy：直接抛出异常，默认使用此策略</li>
<li>CallerFunsPolicy：用调用者所在的线程执行任务</li>
<li>DIscartOldestPolicy：丢弃阻塞队列里最老的任务，也就是队列里最靠前的任务</li>
<li>DiscardPolicy：当前任务直接丢弃</li>
<li>自定义：实现RejectExecutionHandler接口即可。</li>
</ol></blockquote>
<h1>5、线程池提交excute和submit有什么区别</h1>
<h2 data-start="185" data-end="201">(1) execute()</h2>
<ul data-start="202" data-end="377">
<li data-start="202" data-end="241">
用法：<code data-start="207" data-end="239">void execute(Runnable command)</code>
</li>
<li data-start="242" data-end="377">
特点：
<ul data-start="252" data-end="377">
<li data-start="252" data-end="277">
只能提交 Runnable 任务；
</li>
<li data-start="280" data-end="294">
没有返回值；
</li>
<li data-start="297" data-end="377">
如果任务抛出异常，异常会直接抛到线程中，最终由线程的 UncaughtExceptionHandler 或 <code data-start="357" data-end="371">afterExecute</code> 捕获
</li>
</ul>
</li>
</ul>
<div class="cnblogs_code">
<pre>(1) execute()

用法：void execute(Runnable command)

特点：

只能提交 Runnable 任务；

没有返回值；

如果任务抛出异常，异常会直接抛到线程中，最终由线程的 UncaughtExceptionHandler 或 afterExecute 捕获。</pre>
</div>
<h2 data-start="550" data-end="565">(2) submit()</h2>
<ul data-start="566" data-end="823">
<li data-start="566" data-end="660">
用法：
<ul data-start="576" data-end="660">
<li data-start="576" data-end="613">
<code data-start="578" data-end="611">Future<?> submit(Runnable task)</code>
</li>
<li data-start="616" data-end="660">
<code data-start="618" data-end="658"><T> Future<T> submit(Callable<T> task)</code>
</li>
</ul>
</li>
<li data-start="661" data-end="823">
特点：
<ul data-start="671" data-end="823">
<li data-start="671" data-end="707">
可以提交 Runnable 或 Callable 任务；
</li>
<li data-start="710" data-end="748">
返回 Future 对象，可以获取结果、取消任务、捕获异常；
</li>
<li data-start="751" data-end="823">
如果任务抛出异常，异常会被封装在 <code data-start="770" data-end="778">Future</code> 中，只有调用 <code data-start="786" data-end="793">get()</code> 时才会抛出 <code data-start="800" data-end="820">ExecutionException</code>。
</li>
</ul>
</li>
</ul>
<div class="cnblogs_code">
<pre>(2) submit()

用法：

Future<?> submit(Runnable task)

<T> Future<T> submit(Callable<T> task)

特点：

可以提交 Runnable 或 Callable 任务；

返回 Future 对象，可以获取结果、取消任务、捕获异常；

如果任务抛出异常，异常会被封装在 Future 中，只有调用 get() 时才会抛出 ExecutionException。</pre>
</div>
<h1>6、线程池怎么关闭</h1>
(1) shutdown()
<ul data-start="87" data-end="191">
<li data-start="87" data-end="129">
行为：停止接收新任务；已提交的任务（正在执行的 + 队列中等待的）会执行完。
</li>
<li data-start="130" data-end="151">
特点：平滑关闭，常用方式。
</li>
<li data-start="152" data-end="191">
注意：调用后线程池状态会变为 SHUTDOWN，不会立刻终止。
</li>
</ul>
(2) shutdownNow()
<ul data-start="217" data-end="338">
<li data-start="217" data-end="256">
行为：停止接收新任务，清空队列中的等待任务，并尝试中断正在执行的任务。
</li>
<li data-start="257" data-end="274">
返回值：未执行的任务列表。
</li>
<li data-start="275" data-end="307">
特点：强制关闭，风险较大（可能造成数据不一致）。
</li>
<li data-start="308" data-end="338">
注意：线程是否真正中断，取决于任务代码是否响应中断。
</li>
</ul>
(3) awaitTermination(timeout, unit)
<ul data-start="382" data-end="611">
<li data-start="382" data-end="508">
用法：
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary">
<div class="sticky top-9"> </div>
<div class="overflow-y-auto p-4" dir="ltr"><code class="whitespace-pre! language-java">pool.shutdown(); if (!pool.awaitTermination(60, TimeUnit.SECONDS)) { pool.shutdownNow(); } </code></div>
</div>
</li>
<li data-start="509" data-end="582">
作用：在调用 <code data-start="518" data-end="530">shutdown()</code> 后等待一段时间，如果线程池没有在指定时间内终止，再调用 <code data-start="559" data-end="574">shutdownNow()</code> 强制关闭。
</li>
<li data-start="583" data-end="611">
特点：常用于“优雅关闭”+“兜底强制关闭”组合。
</li>
</ul>
(4) isShutdown() / isTerminated()
<ul data-start="653" data-end="790">
<li data-start="653" data-end="717">
<code data-start="655" data-end="669">isShutdown()</code>：调用 <code data-start="673" data-end="685">shutdown()</code> 或 <code data-start="688" data-end="703">shutdownNow()</code> 后返回 <code data-start="708" data-end="714">true</code>。
</li>
<li data-start="718" data-end="766">
<code data-start="720" data-end="736">isTerminated()</code>：所有任务执行结束，线程池完全终止时返回 <code data-start="757" data-end="763">true</code>。
</li>
<li data-start="767" data-end="790">
可配合轮询检测线程池状态，做收尾逻辑。
</li>
</ul>
<h1>7、线程池的线程数应该怎么配置</h1>
(1) 计算密集型任务
<ul data-start="93" data-end="191">
<li data-start="93" data-end="117">
特点：大部分时间消耗在 CPU 运算上。
</li>
<li data-start="118" data-end="137">
配置：<code data-start="123" data-end="134">CPU核数 + 1</code>。
</li>
<li data-start="138" data-end="191">
理由：核心数保证最大并行度，额外的 <code data-start="158" data-end="162">+1</code> 用来应对偶尔的线程挂起（页缺失、GC、上下文切换）。
</li>
</ul>
(2) IO 密集型任务
<ul data-start="212" data-end="314">
<li data-start="212" data-end="242">
特点：大部分时间等待 IO（数据库、网络、磁盘等）。
</li>
<li data-start="243" data-end="280">
配置：<code data-start="248" data-end="259">CPU核数 * 2</code>（甚至更高，取决于 IO 等待比例）。
</li>
<li data-start="281" data-end="314">
理由：IO 期间线程空闲，更多线程可提升 CPU 利用率。
</li>
</ul>
(3) 混合型任务
<ul data-start="332" data-end="450">
<li data-start="332" data-end="352">
特点：既包含计算，又包含 IO。
</li>
<li data-start="353" data-end="450">
配置方法：
<ul data-start="365" data-end="450">
<li data-start="365" data-end="402">
比例分解法：根据任务中 IO 和计算占比，估算最优线程数。
</li>
<li data-start="405" data-end="450">
分池法：将任务拆分为计算型和 IO 型，分别放入不同线程池，避免资源竞争。
</li>
</ul>
</li>
</ul>
(4) 经验公式（IO 密集型可参考）
线程数=CPU核心数×(1+IO时间计算时间)线程数 = CPU核心数 \times (1 + \frac{IO时间}{计算时间})线程数=CPU核心数×(1+计算时间IO时间)
<ul data-start="530" data-end="559">
<li data-start="530" data-end="559">
如果 IO 占比高，线程数可比 CPU 数大得多。
</li>
</ul>
<h1>8、有哪几种常见的线程池</h1>
(1) newFixedThreadPool
<ul data-start="130" data-end="314">
<li data-start="130" data-end="158">
核心线程数 = 最大线程数 = 固定值。
</li>
<li data-start="159" data-end="193">
keepAliveTime = 0，线程不会被回收。
</li>
<li data-start="194" data-end="235">
阻塞队列 = LinkedBlockingQueue（无界队列）。
</li>
<li data-start="236" data-end="261">
特点：线程数固定，任务多了就排队。
</li>
<li data-start="262" data-end="314">
适用场景：适合 CPU 密集型任务，线程数可设置为 <code data-start="298" data-end="307">CPU 核心数</code> 或略大。
</li>
</ul>
(2) newCachedThreadPool
<ul data-start="351" data-end="580">
<li data-start="351" data-end="405">
核心线程数 = 0；最大线程数 = <code data-start="375" data-end="394">Integer.MAX_VALUE</code>（相当于无限大）。
</li>
<li data-start="406" data-end="446">
keepAliveTime = 60s，空闲线程超过时间会回收。
</li>
<li data-start="447" data-end="496">
阻塞队列 = SynchronousQueue（没有容量，任务直接交给线程执行）。
</li>
<li data-start="497" data-end="529">
特点：任务多就创建新线程，空闲一段时间自动回收。
</li>
<li data-start="530" data-end="580">
适用场景：适合 大量并发的短期小任务，但要注意可能导致线程数过多，风险较大。
</li>
</ul>
(3) newSingleThreadExecutor
<ul data-start="621" data-end="801">
<li data-start="621" data-end="647">
核心线程数 = 最大线程数 = 1。
</li>
<li data-start="648" data-end="674">
keepAliveTime = 0。
</li>
<li data-start="675" data-end="716">
阻塞队列 = LinkedBlockingQueue（无界队列）。
</li>
<li data-start="717" data-end="755">
特点：单线程串行执行，保证任务按照提交顺序（FIFO）执行。
</li>
<li data-start="756" data-end="801">
适用场景：适合 需要顺序执行任务、或全局只需要一个后台线程的场景。
</li>
</ul>
(4) newScheduledThreadPool
<ul data-start="841" data-end="1003">
<li data-start="841" data-end="889">
核心线程数 = 指定值；最大线程数 = <code data-start="867" data-end="886">Integer.MAX_VALUE</code>。
</li>
<li data-start="890" data-end="916">
keepAliveTime = 0。
</li>
<li data-start="917" data-end="943">
阻塞队列 = DelayQueue。
</li>
<li data-start="944" data-end="968">
特点：支持定时和周期性任务调度。
</li>
<li data-start="969" data-end="1003">
适用场景：适合定时执行任务（如心跳检测、周期任务）。
</li>
</ul>
(5) newWorkStealingPool（JDK 1.8+ 新增）
<ul data-start="1053" data-end="1237">
<li data-start="1053" data-end="1078">
使用 <code data-start="1058" data-end="1072">ForkJoinPool</code> 实现。
</li>
<li data-start="1079" data-end="1149">
核心线程数 = CPU 核心数（<code data-start="1101" data-end="1145">Runtime.getRuntime().availableProcessors()</code>）。
</li>
<li data-start="1150" data-end="1197">
特点：基于“工作窃取算法”，空闲线程可以从其他线程队列里偷任务执行，负载均衡。
</li>
<li data-start="1198" data-end="1237">
适用场景：适合 大批量、小任务并行计算（如分治计算）。
</li>
</ul>
<h1>9、线程池异常怎么处理？</h1>
　　在使用线程池时，经常会遇到这样的情况：线程池本身没问题，但任务（Runnable/Callable）运行过程中抛出了异常。 
如果没有额外处理，这些异常可能会被“吞掉”，导致我们难以及时发现问题。
本文总结了常见的几种线程池任务异常处理方式。
<h2 data-start="230" data-end="252">(1) 在任务内部 try-catch</h2>
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary">
<div class="overflow-y-auto p-4" dir="ltr">
<div class="cnblogs_code">
<pre>pool.execute(() -> {
try {
 int a = 1 / 0;
} catch (Exception e) {
 System.err.println("任务异常: " + e.getMessage());
}
});</pre>
</div>
</div>
</div>
优点：简单直观，能捕获异常。 
缺点：需要每个任务都写 <code data-start="451" data-end="462">try/catch</code>，容易遗漏，不够统一。
<h2 data-start="482" data-end="516">(2) <code data-start="489" data-end="499">submit()</code> + <code data-start="502" data-end="516">Future.get()</code></h2>
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary">
<div class="overflow-y-auto p-4" dir="ltr">
<div class="cnblogs_code">
<pre>Future<?> future = pool.submit(() -> {
int a = 1 / 0;
});

try {
future.get(); // 会抛 ExecutionException
} catch (Exception e) {
System.err.println("捕获到异常: " + e.getCause());
}</pre>
</div>
</div>
</div>
特点：
<ul data-start="729" data-end="850">
<li data-start="729" data-end="764">
使用 <code data-start="734" data-end="744">submit()</code> 提交任务会返回 <code data-start="753" data-end="761">Future</code>；
</li>
<li data-start="765" data-end="815">
如果调用 <code data-start="772" data-end="779">get()</code>，会抛出 <code data-start="784" data-end="804">ExecutionException</code>，异常可以被捕获；
</li>
<li data-start="816" data-end="850">
但如果 不调用 <code data-start="828" data-end="835">get()</code>，异常就会被“吞掉”。
</li>
</ul>
适合需要拿任务返回值的场景。
<h2 data-start="875" data-end="914">(3) 设置线程的 <code data-start="888" data-end="914">UncaughtExceptionHandler</code></h2>
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary">
<div class="sticky top-9"> 
<div class="cnblogs_code">
<pre>ThreadFactory factory = r -> {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler((thread, e) ->
 System.err.println(thread.getName() + " 出错了: " + e));
return t;
};

ExecutorService pool = new ThreadPoolExecutor(
2, 4, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(), factory
);

pool.execute(() -> { int a = 1 / 0; });

//输出示例：
pool-1-thread-1 出错了: java.lang.ArithmeticException: / by zero</pre>
</div>
</div>
</div>
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary"> </div>
特点：
<ul data-start="1371" data-end="1500">
<li data-start="1371" data-end="1391">
给线程绑定一个全局的异常处理器。
</li>
<li data-start="1392" data-end="1427">
任务里不用写 <code data-start="1401" data-end="1412">try/catch</code>，异常会被统一捕获和处理。
</li>
<li data-start="1428" data-end="1454">
适用于 <code data-start="1434" data-end="1445">execute()</code> 提交的任务。
</li>
<li data-start="1455" data-end="1500">
但对 <code data-start="1460" data-end="1470">submit()</code> 提交的异常无效（因为被封装到 <code data-start="1486" data-end="1494">Future</code> 里）。
</li>
</ul>
<h2 data-start="1507" data-end="1533">(4) 重写 <code data-start="1517" data-end="1533">afterExecute()</code></h2>
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary">
<div class="sticky top-9">
<div class="cnblogs_code">
<pre>ExecutorService pool = new ThreadPoolExecutor(2, 4, 60,
 TimeUnit.SECONDS, new LinkedBlockingQueue<>()) {
@Override
protected void afterExecute(Runnable r, Throwable t) {
 super.afterExecute(r, t);
 if (t != null) {
 System.err.println("execute 出错: " + t);
 }
 if (r instanceof Future<?>) {
 try {
 ((Future<?>) r).get();
 } catch (Exception e) {
 System.err.println("submit 出错: " + e.getCause());
 }
 }
}
};

// execute 提交的异常
pool.execute(() -> { int a = 1 / 0; });

// submit 提交的异常
pool.submit(() -> { return 1 / 0; });

//输出
execute 出错: java.lang.ArithmeticException: / by zero
submit 出错: java.lang.ArithmeticException: / by zero</pre>
</div>
</div>
</div>
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary"> </div>
特点：
<ul>
<li data-start="2316" data-end="2325"><code data-start="2328" data-end="2331">t</code> 参数能捕获 <code data-start="2338" data-end="2349">execute()</code> 的异常；</li>
<li data-start="2316" data-end="2325"><code data-start="2359" data-end="2373">Future.get()</code> 能捕获 <code data-start="2378" data-end="2388">submit()</code> 的异常；</li>
<li data-start="2316" data-end="2325">这样就能 统一捕获 <code data-start="2410" data-end="2419">execute</code> 和 <code data-start="2422" data-end="2430">submit</code> 的异常；</li>
<li data-start="2316" data-end="2325">比单纯的 <code data-start="2447" data-end="2473">UncaughtExceptionHandler</code> 更全面。</li>
</ul>
<h1>10、说一下线程池有几种状态</h1>
(1) RUNNING
<ul data-start="97" data-end="202">
<li data-start="97" data-end="130">
默认初始状态，可以接受新任务，也可以处理阻塞队列中的任务。
</li>
<li data-start="131" data-end="202">
调用 <code data-start="136" data-end="148">shutdown()</code> → 转为 SHUTDOWN；调用 <code data-start="170" data-end="185">shutdownNow()</code> → 转为 STOP。
</li>
</ul>
(2) SHUTDOWN
<ul data-start="223" data-end="295">
<li data-start="223" data-end="258">
不再接受新任务，但会继续处理阻塞队列中的任务和正在执行的任务。
</li>
<li data-start="259" data-end="295">
当队列为空且活动线程数为 0 → 转为 TIDYING。
</li>
</ul>
(3) STOP
<ul data-start="312" data-end="404">
<li data-start="312" data-end="337">
不再接受新任务，也不处理阻塞队列中的任务。
</li>
<li data-start="338" data-end="376">
会中断正在运行的任务（通过调用线程的 <code data-start="359" data-end="372">interrupt()</code>）。
</li>
<li data-start="377" data-end="404">
一般由 <code data-start="383" data-end="398">shutdownNow()</code> 触发。
</li>
</ul>
(4) TIDYING
<ul data-start="424" data-end="500">
<li data-start="424" data-end="445">
所有任务都结束，活动线程数为 0。
</li>
<li data-start="446" data-end="483">
会执行 <code data-start="452" data-end="466">terminated()</code> 钩子方法，通常用于清理资源。
</li>
<li data-start="484" data-end="500">
是进入终止前的过渡状态。
</li>
</ul>
(5) TERMINATED
<ul data-start="523" data-end="544">
<li data-start="523" data-end="544">
线程池彻底终止，生命周期完全结束。
</li>
</ul>
<div class="cnblogs_code">
<pre> ┌───────────┐ shutdown() ┌───────────┐
 │RUNNING│ ──────────────▶ │ SHUTDOWN│
 └─────┬─────┘ └─────┬─────┘
shutdownNow()│ │
 ▼ ▼
 ┌───────┐ 任务清空 ┌───────────┐
 │ STOP│ ─────────────────▶ │ TIDYING │
 └───────┘ └─────┬─────┘
 │ terminated()
 ▼
 ┌───────────┐
 │TERMINATED │
 └───────────┘</pre>
</div>
<h1>11、线程池如何实现参数的动态修改</h1>
(1) ThreadPoolExecutor 提供的 setter 方法
<ul data-start="108" data-end="399">
<li data-start="108" data-end="147">
<code data-start="110" data-end="145">setCorePoolSize(int corePoolSize)</code>
</li>
<li data-start="148" data-end="193">
<code data-start="150" data-end="191">setMaximumPoolSize(int maximumPoolSize)</code>
</li>
<li data-start="194" data-end="242">
<code data-start="196" data-end="240">setKeepAliveTime(long time, TimeUnit unit)</code>
</li>
<li data-start="243" data-end="294">
<code data-start="245" data-end="292">setThreadFactory(ThreadFactory threadFactory)</code>
</li>
<li data-start="295" data-end="399">
<code data-start="297" data-end="360">setRejectedExecutionHandler(RejectedExecutionHandler handler)</code> 
👉 这些方法可在运行时动态修改参数，但线程池本身不会主动感知变化。

</li>

</ul>
(2) 配置中心动态下发
<ul data-start="425" data-end="537">
<li data-start="425" data-end="475">
使用 Nacos / Apollo / Spring Cloud Config 等配置中心。

</li>
<li data-start="476" data-end="516">
配置变更后应用自动收到通知，调用 <code data-start="495" data-end="505">setXxx()</code> 方法完成热更新。

</li>
<li data-start="517" data-end="537">
适合分布式环境，可全局统一调整。

</li>

</ul>
(3) 自定义监听方案
<ul data-start="562" data-end="646">
<li data-start="562" data-end="596">
没有配置中心时，可以定时读取数据库/文件/Redis 配置。

</li>
<li data-start="597" data-end="628">
如果参数发生变化，就调用 <code data-start="612" data-end="622">setXxx()</code> 更新。

</li>
<li data-start="629" data-end="646">
简单易实现，但有一定延迟。

</li>

</ul>
(4) 结合监控系统
<ul data-start="670" data-end="737">
<ul data-start="670" data-end="737">
<li data-start="670" data-end="704">
可通过队列长度、任务堆积、CPU 使用率等指标触发动态调整。

</li>
<li data-start="705" data-end="737">
常见实践：监控 + 自动调节，或人工结合监控后台改配置。

</li>

</ul>
</ul>
<h1>12、单机线程池执行断电了怎么处理</h1>
(1) 阻塞队列持久化
<ul data-start="187" data-end="264">
<li data-start="187" data-end="238">
默认的内存队列断电即丢失，可替换为消息队列（Kafka、RocketMQ、RabbitMQ）。
</li>
<li data-start="239" data-end="264">
确保任务在宕机后依然存在，重启可继续消费。
</li>
</ul>
(2) 正在处理任务的事务控制
<ul data-start="288" data-end="334">
<li data-start="288" data-end="309">
对数据库操作使用事务，保证原子性。
</li>
<li data-start="310" data-end="334">
避免“库存减了但订单没落库”这类不一致。
</li>
</ul>
(3) 断电任务的回滚与日志恢复
<ul data-start="359" data-end="410">
<li data-start="359" data-end="389">
在任务执行前记录操作日志，异常中断后可根据日志恢复。
</li>
<li data-start="390" data-end="410">
常见于支付、退款等高一致性业务。
</li>
</ul>
(4) 服务器重启后的任务恢复
<ul data-start="434" data-end="488">
<li data-start="434" data-end="470">
将待执行任务元信息存入数据库/文件，重启时加载并重新提交线程池。
</li>
<li data-start="471" data-end="488">
常用于定时清算、对账任务。
</li>
</ul>
<h1>13、Fork/Join框架了解吗</h1>
<h2 data-start="117" data-end="140">（1）什么是 Fork/Join 框架？</h2>
<ul data-start="141" data-end="389">
<li data-start="141" data-end="189">
Java7 引入的并行计算框架，位于 <code data-start="162" data-end="184">java.util.concurrent</code> 包。
</li>
<li data-start="190" data-end="245">
设计目标：充分利用多核 CPU，支持大任务拆分（Fork）+ 小任务合并（Join）。
</li>
<li data-start="246" data-end="389">
基础类：
<ul data-start="257" data-end="389">
<li data-start="257" data-end="289">
<code data-start="259" data-end="273">ForkJoinPool</code> → 线程池，负责任务调度；
</li>
<li data-start="292" data-end="389">
<code data-start="294" data-end="308">ForkJoinTask</code> → 抽象任务类，常用子类：
<ul data-start="329" data-end="389">
<li data-start="329" data-end="357">
<code data-start="331" data-end="349">RecursiveTask<V></code>：有返回值；
</li>
<li data-start="362" data-end="389">
<code data-start="364" data-end="381">RecursiveAction</code>：无返回值。
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 data-start="396" data-end="406">（2）工作原理</h2>
<ol data-start="407" data-end="612">
<li data-start="407" data-end="432">
分而治之：将大任务拆分成小任务。
</li>
<li data-start="433" data-end="476">
并行执行：小任务由 <code data-start="450" data-end="464">ForkJoinPool</code> 中的工作线程执行。
</li>
<li data-start="477" data-end="519">
结果合并：子任务完成后通过 <code data-start="498" data-end="506">join()</code> 返回结果，逐级汇总。
</li>
<li data-start="520" data-end="612">
工作窃取 (Work Stealing)：
<ul data-start="554" data-end="612">
<li data-start="554" data-end="573">
每个工作线程维护一个双端队列；
</li>
<li data-start="577" data-end="612">
当某个线程空闲，会从别的线程队列“偷”任务执行，避免线程闲置。
</li>
</ul>
</li>
</ol>
<h2 data-start="619" data-end="629">（3）示例代码</h2>
求和 <code data-start="633" data-end="646">1+2+...+100</code>，设置阈值 <code data-start="652" data-end="666">THRESHOLD=16</code>：
<div class="contain-inline-size rounded-2xl relative bg-token-sidebar-surface-primary">
<div class="sticky top-9"> 
<div class="cnblogs_code">
<pre>public class CountTask extends RecursiveTask<Integer> {
private static final int THRESHOLD = 16;
private int start, end;

public CountTask(int start, int end) {
 this.start = start;
 this.end = end;
}

@Override
protected Integer compute() {
 int sum = 0;
 boolean canCompute = (end - start) <= THRESHOLD;

 if (canCompute) {
 for (int i = start; i <= end; i++) {
 sum += i;
 }
 } else {
 int middle = (start + end) / 2;
 CountTask leftTask = new CountTask(start, middle);
 CountTask rightTask = new CountTask(middle + 1, end);

 leftTask.fork(); // 提交左任务
 int rightResult = rightTask.compute(); // 当前线程直接算右任务
 int leftResult = leftTask.join(); // 等待左任务结果

 sum = leftResult + rightResult;
 }
 return sum;
}

public static void main(String[] args) throws Exception {
 ForkJoinPool pool = new ForkJoinPool();
 CountTask task = new CountTask(1, 100);
 Future<Integer> result = pool.submit(task);
 System.out.println("结果: " + result.get());
}
}</pre>
</div>
</div>
</div>
输出：<code class="whitespace-pre!">结果: 5050</code>
<h2 data-start="1890" data-end="1900">（4）注意事项</h2>
<ol data-start="1901" data-end="2290">
<li data-start="1901" data-end="1958">
不要无限制拆分任务
<ul data-start="1923" data-end="1958">
<li data-start="1923" data-end="1958">
设置合理的 <code data-start="1931" data-end="1942">THRESHOLD</code>，否则递归太深，性能反而差。
</li>
</ul>
</li>
<li data-start="1959" data-end="2082">
fork/join 的调用顺序
<ul data-start="1987" data-end="2082">
<li data-start="1987" data-end="2050">
推荐：<code data-start="1992" data-end="2048">leftTask.fork(); rightTask.compute(); leftTask.join();</code>
</li>
<li data-start="2054" data-end="2082">
避免所有子任务都 fork，导致线程间竞争严重。
</li>
</ul>
</li>
<li data-start="2083" data-end="2133">
异常处理
<ul data-start="2100" data-end="2133">
<li data-start="2100" data-end="2133">
子任务异常会传播到 <code data-start="2112" data-end="2120">join()</code> 时抛出，要注意捕获。
</li>
</ul>
</li>
<li data-start="2134" data-end="2199">
线程数
<ul data-start="2150" data-end="2199">
<li data-start="2150" data-end="2199">
默认 = CPU 核心数，通常够用；也可指定 <code data-start="2175" data-end="2196">new ForkJoinPool(n)</code>。
</li>
</ul>
</li>
<li data-start="2200" data-end="2290">
和普通线程池区别
<ul data-start="2221" data-end="2290">
<li data-start="2221" data-end="2249">
普通线程池 → 任务彼此独立，适合 IO 密集；
</li>
<li data-start="2253" data-end="2290">
Fork/Join → 大任务拆小任务，适合 CPU 密集型计算。
</li>
</ul>
</li>
</ol>
<h2 data-start="2297" data-end="2305">（5）总结</h2>
<ul data-start="2306" data-end="2478">
<li data-start="2306" data-end="2366">
Fork/Join 是 并行递归计算的利器，适合大规模、可拆分的任务（如矩阵计算、归并排序、递归求和）。
</li>
<li data-start="2367" data-end="2411">
核心思想：任务拆分 + 线程池执行 + 结果合并 + 工作窃取负载均衡。
</li>
<li data-start="2412" data-end="2478">
编写任务时要重点关注：
<ul data-start="2430" data-end="2478">
<li data-start="2430" data-end="2441">
合理拆分任务；
</li>
<li data-start="2444" data-end="2457">
避免过多的小任务；
</li>
<li data-start="2460" data-end="2478">
注意异常处理和结果合并逻辑。
</li>
</ul>
</li>
</ul>
 
<h2>参考</h2>
 沉默王二公众号 
来源：https://www.cnblogs.com/xiaoqian01/p/19091610

頁: [1]

琼殿技术论坛's Archiver

Java并发编程（5）