目录
为什么使用线程池
线程其实也是一种系统资源，每次创建线程，都会创建对应的栈内存，如果线程非常多，那么可能会占用非常多的系统资源。
另外一方面，线程也不是越多越好的，CPU资源是有限的，即使有很多线程，还是需要等待CPU调度分配资源，还有上下文切换等，也是非常耗时的操作。
所以就有了线程池的概念。
所谓的线程池其实就是一批线程的集合，这些线程可以得到重复利用，这样减少了内存占用和线程数量，也减少了上下文切换。
使用线程池主要有以下三个原因：
- 创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
- 控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）
- 可以对线程做统一管理。
ThreadPoolExecutor
构造方法
在java中，使用ThreadPoolExecutor来实现线程池。其中构造方法有很多，最全的方法如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
下面看下各个参数什么意思：
-
int corePoolSize：该线程池中核心线程数最大值。核心线程：线程池中有两类线程，核心线程和非核心线程（又叫救急线程）。核心线程默认情况下会一直存在于线程池中，即使这个核心线程什么都不干（铁饭碗），而非核心线程如果长时间的闲置，就会被销毁（临时工）。
-
int maximumPoolSize：该线程池中线程总数最大值 。该值等于核心线程数量 + 非核心线程数量。 -
long keepAliveTime：非核心线程闲置超时时长。非核心线程如果处于闲置状态超过该值，就会被销毁。如果设置allowCoreThreadTimeOut(true)，则会也作用于核心线程。 -
TimeUnit unit：keepAliveTime的单位。TimeUnit是一个枚举类型 ，包括以下属性：
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000 MICROSECONDS ： 1微秒 = 1毫秒 / 1000 MILLISECONDS ： 1毫秒 = 1秒 /1000 SECONDS ： 秒 MINUTES ： 分 HOURS ： 小时 DAYS ： 天
-
BlockingQueue workQueue：阻塞队列，维护着等待执行的Runnable任务对象。常用的几个阻塞队列：
- LinkedBlockingQueue：链式阻塞队列，底层数据结构是链表，默认大小是
Integer.MAX_VALUE，也可以指定大小。 - ArrayBlockingQueue：数组阻塞队列，底层数据结构是数组，需要指定队列的大小。
- SynchronousQueue：同步队列，内部容量为0，每个put操作必须等待一个take操作，反之亦然。
- DelayQueue：延迟队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素 。
- LinkedBlockingQueue：链式阻塞队列，底层数据结构是链表，默认大小是
-
ThreadFactory threadFactory：非必须参数。创建线程的工厂 ，用于批量创建线程，统一在创建线程时设置一些参数，如是否守护线程、线程的优先级等。如果不指定，会新建一个默认的线程工厂。 -
RejectedExecutionHandler handler：拒绝处理策略，线程数量大于最大线程数就会采用拒绝处理策略。jdk 提供了 4 种实现拒绝策略，如下：
- ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出RejectedExecutionException异常。
- ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。
- ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列头部（最旧的）的任务，然后重新尝试执行程序（如果再次失败，重复此过程）。
- ThreadPoolExecutor.CallerRunsPolicy：由调用线程自己处理该任务。
线程池的状态
线程池本身有一个调度线程，这个线程就是用于管理布控整个线程池里的各种任务和事务，例如创建线程、销毁线程、任务队列管理、线程队列管理等等。
故线程池也有自己的状态。ThreadPoolExecutor类中定义了一个volatile int变量runState来表示线程池的状态 ，分别为RUNNING、SHURDOWN、STOP、TIDYING 、TERMINATED。
ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量。
| 状态名 | 高 3 位 | 接收新任务 | 处理阻塞队列任务 | 说明 |
|---|---|---|---|---|
| RUNNING | 111 | Y | N | |
| SHUTDOWN | 000 | N | Y | 不会接收新任务，但会处理阻塞队列剩余任务 |
| STOP | 001 | N | N | 会中断正在执行的任务，并抛弃阻塞队列 |
| TIDYING | 010 | - | - | 任务全执行完毕，活动线程为 0 即将进入终结 |
| TERMINATED | 011 | - | - | 终结状态 |
从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING。
这些信息存储在一个原子变量（AtomicInteger） ctl 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作进行赋值。
// c 为旧值， ctlOf 返回结果为新值
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))));
// rs 为高 3 位代表线程池状态， wc 为低 29 位代表线程个数，ctl 是合并它们
private static int ctlOf(int rs, int wc) { return rs | wc; }
线程池的工作策略如下：
-
线程池创建后处于RUNNING状态。
-
调用shutdown()方法后处于SHUTDOWN状态，线程池不能接受新的任务，清除一些空闲worker，会等待阻塞队列的任务完成。
-
调用shutdownNow()方法后处于STOP状态，线程池不能接受新的任务，中断所有线程，阻塞队列中没有被执行的任务全部丢弃。此时，poolsize=0,阻塞队列的size也为0。
-
当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。接着会执行terminated()函数。
-
线程池处在TIDYING状态时，执行完terminated()方法之后，就会由 TIDYING -> TERMINATED， 线程池被设置为TERMINATED状态。
线程池任务处理流程
处理任务的核心方法是execute，我们看看 JDK 1.8 源码中ThreadPoolExecutor是如何处理线程任务的：
// JDK 1.8
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
// 获取线程池状态
int c = ctl.get();
// 1.当前线程数小于corePoolSize,则调用addWorker创建核心线程执行任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 2.如果不小于corePoolSize，则将任务添加到workQueue队列。
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执行拒绝策略。
if (! isRunning(recheck) && remove(command))
reject(command);
// 2.2 线程池处于running状态，但是没有线程，则创建线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 3.如果放入workQueue失败，则创建非核心线程执行任务，
// 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时)，就会执行拒绝策略。
else if (!addWorker(command, false))
reject(command);
}
ctl.get()是获取线程池状态，用int类型表示。第二步中，入队前进行了一次isRunning判断，入队之后，又进行了一次isRunning判断。
为什么要二次检查线程池的状态?
在多线程的环境下，线程池的状态是时刻发生变化的。很有可能刚获取线程池状态后线程池状态就改变了。判断是否将
command加入workqueue是线程池之前的状态。倘若没有二次检查，万一线程池处于非RUNNING状态（在多线程环境下很有可能发生），那么command永远不会执行。
总结一下处理流程
- 线程总数量 < corePoolSize，无论线程是否空闲，都会新建一个核心线程执行任务（让核心线程数量快速达到corePoolSize，在核心线程数量 < corePoolSize时）。注意，这一步需要获得全局锁。
- 线程总数量 >= corePoolSize时，新来的线程任务会进入任务队列中等待，然后空闲的核心线程会依次去缓存队列中取任务来执行（体现了线程复用）。
- 当缓存队列满了，说明这个时候任务已经多到爆棚，需要一些“临时工”来执行这些任务了。于是会创建非核心线程去执行这个任务。注意，这一步需要获得全局锁。
- 缓存队列满了， 且总线程数达到了maximumPoolSize，则会采取上面提到的拒绝策略进行处理。
线程池种类
说明：
下面要说的线程池的创建都是通过Executors创建，但是阿里的开发规范里，不推荐使用Executors去创建线程池，而是通过ThreadPoolExecutor的方式创建，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 主要因为允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
但如果如果本身对线程池非常熟悉，又确定业务规模不会大到资源耗尽的程度（比如线程数量或任务队列长度可能达到Integer.MAX_VALUE）时，其实是可以使用JDK提供的这几个接口的，它能让我们的代码具有更强的可读性。
newFixedThreadPool
固定大小线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
核心线程数量和总线程数量都是传入的参数nThreads，两者相等，所以只能创建核心线程，不能创建非核心线程。因为LinkedBlockingQueue的默认大小是Integer.MAX_VALUE，即是无界队列，队列里的线程数量可以非常大。
如果核心线程空闲，则交给核心线程处理；如果核心线程不空闲，则入列等待，直到核心线程空闲。
在 getTask() 方法，如果队列里没有任务可取，线程会一直阻塞在 LinkedBlockingQueue.take() ，线程不会被回收，会一直卡在阻塞，所以没有任务的情况下， FixedThreadPool占用资源更多。
示例：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Slf4j
public class FixedThreadPoolTest01 {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
pool.execute(() -> {
log.info("线程1");
});
pool.execute(() -> {
log.info("线程2");
});
pool.execute(() -> {
log.info("线程3");
});
}
}
执行如下：
2023-07-03 00:24:35,528 - 0 INFO [pool-1-thread-1] up.cys.chapter07.FixedThreadPoolTest01:18 - 线程1
2023-07-03 00:24:35,528 - 0 INFO [pool-1-thread-2] up.cys.chapter07.FixedThreadPoolTest01:21 - 线程2
2023-07-03 00:24:35,538 - 10 INFO [pool-1-thread-1] up.cys.chapter07.FixedThreadPoolTest01:24 - 线程3
执行程序后，发现程序并没有停下来，后面会说如何处理。
还可以看到打印出的线程名字，比如第一个[pool-1-thread-1]，是使用的默认的线程工厂创建的名字，默认的线程工厂代码如下：
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
还可以使用自己创建的线程工厂，如下：
@Slf4j
public class FixedThreadPoolTest01 {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2, new ThreadFactory() {
private AtomicInteger t = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "myPool-" + t.getAndIncrement());
}
});
pool.execute(() -> {
log.info("线程1");
});
pool.execute(() -> {
log.info("线程2");
});
pool.execute(() -> {
log.info("线程3");
});
}
}
适用于任务量已知，相对耗时的任务。
newCachedThreadPool
带缓冲的线程池
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
其特点是，核心线程数是 0， 最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s。
也就是说它的线程全部都是救急线程（60s 后可以回收），且救急线程可以无限创建。
另外，队列采用了 SynchronousQueue 实现特点是，它没有容量，没有其他线程来取会阻塞住，任务放不进去的（一手交钱、一手交货）。
CacheThreadPool的运行流程如下：
- 提交任务进线程池。
- 因为corePoolSize为0的关系，不创建核心线程，线程池最大为Integer.MAX_VALUE。
- 尝试将任务添加到SynchronousQueue队列。
- 如果SynchronousQueue入列成功，立马当前空闲的线程拉取执行。如果当前没有空闲线程，那么就创建一个非核心线程，然后从SynchronousQueue拉取任务并在当前线程执行。
- 如果SynchronousQueue已有任务在等待，入列操作将会阻塞。
当需要执行很多短时间的任务时，CacheThreadPool的线程复用率比较高， 会显著的提高性能。而且线程60s后会回收，意味着即使没有任务进来，CacheThreadPool并不会占用很多资源。
整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线程。 适合任务数比较密集，但每个任务执行时间较短的情况。
FixedThreadPool是因为阻塞队列可以很大（最大为Integer最大值），故几乎不会触发拒绝策略；CachedThreadPool是因为线程池很大（最大为Integer最大值），几乎不会导致线程数量大于最大线程数，故几乎不会触发拒绝策略。
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
有且仅有一个核心线程（ corePoolSize == maximumPoolSize=1），使用了LinkedBlockingQueue（容量很大），所以，不会创建非核心线程。所有任务按照先来先执行的顺序执行。如果这个唯一的线程不空闲，那么新来的任务会存储在任务队列里等待执行。
newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
示例：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class ScheduledExecutorTest01 {
public static void main(String[] args) {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
log.info("开始");
// 创建一个任务，延迟一秒执行
pool.schedule(() -> {
log.info("task1");
int i = 1 / 0;
}, 1, TimeUnit.SECONDS);
pool.schedule(() -> {
log.info("task2");
},1, TimeUnit.SECONDS);
}
}
执行结果如下：
2023-07-03 21:54:48,434 - 0 INFO [main] up.cys.chapter07.ScheduledExecutorTest01:19 - 开始
2023-07-03 21:54:49,450 - 1016 INFO [pool-1-thread-1] up.cys.chapter07.ScheduledExecutorTest01:23 - task1
2023-07-03 21:54:49,452 - 1018 INFO [pool-1-thread-2] up.cys.chapter07.ScheduledExecutorTest01:27 - task2
可以看到，除了延迟1秒执行外，任务1执行异常并不会影响任务2。
除了执行延迟任务，还可以使用scheduleAtFixedRate执行定时任务，如下：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class ScheduledExecutorTest02 {
public static void main(String[] args) {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
log.info("开始");
// 参数里第一个1是延迟多少秒开始第一次执行任务，第二个1是每隔1秒执行一次
pool.scheduleAtFixedRate(() -> {
log.info("running...");
}, 1, 1, TimeUnit.SECONDS);
}
}
执行程序后会每隔1秒打印一下。需要注意的是，如果任务的执行时间（假如2s）大于了间隔时间（假如1s），那么还是得等上次执行完才能再执行下次，也就是得每隔2秒执行一次。
另外还有一个方法，是scheduleWithFixedDelay，他的时间间隔是从上次任务结束开始算的，而上面的是从上次任务开始就算了。这里不再演示。
线程池常用方法
提交任务
- execute
普通的执行任务方法
void execute(Runnable command);
- submit
提交任务 task，用返回值 Future 获得任务执行结果
<T> Future<T> submit(Callable<T> task);
示例：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
@Slf4j
public class SubmitTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService pool = Executors.newFixedThreadPool(2);
Future<String> future = pool.submit(() -> {
log.info("running");
Thread.sleep(1000);
return "ok";
});
log.info("结果：{}", future.get());
}
}
注意使用future.get()或阻塞等待结果。
- invokeAll
提交 tasks 中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
// 带超时时间
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
4 .invokeAny
提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
// 带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
关闭线程池
- shutdown
线程池状态变为 SHUTDOWN，且
- 不会接收新任务
- 已提交到队列的任务会执行完
- 不会阻塞调用线程的执行，也就是调用线程池的线程调用此方法，会接着向下运行
源码如下：
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 修改线程池状态
advanceRunState(SHUTDOWN);
// 仅会打断空闲线程
interruptIdleWorkers();
onShutdown(); // 扩展点 ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 尝试终结(没有运行的线程可以立刻终结，如果还有运行的线程也不会等)
tryTerminate();
}
- shutdownNow
线程池状态变为 STOP，且：
- 不会接收新任务
- 将队列中的任务返回
- 并用 interrupt 的方式中断正在执行的任务
源码如下：
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 修改线程池状态
advanceRunState(STOP);
// 打断所有线程
interruptWorkers();
// 获取队列中剩余任务
tasks = drainQueue();
} finally {
mainLock.unlock();
}
// 尝试终结
tryTerminate();
return tasks;
}
线程池状态
// 不在 RUNNING 状态的线程池，此方法就返回 true
boolean isShutdown();
// 线程池状态是否是 TERMINATED
boolean isTerminated();
// 调用 shutdown 后，由于调用线程并不会等待所有任务运行结束，因此如果它想在线程池 TERMINATED 后做些事情，可以利用此方法等待
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
线程池大小设置
线程池大小设置过小会导致程序不能充分地利用系统资源、容易导致饥饿，过大会导致更多的线程上下文切换，占用更多内存。
下面有经验公式可以参考
- CPU 密集型运算
通常采用 cpu 核数 + 1 能够实现最优的 CPU 利用率，+1 是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证 CPU 时钟周期不被浪费。
- I/O 密集型运算
CPU 不总是处于繁忙状态，例如，当你执行业务计算时，这时候会使用 CPU 资源，但当你执行 I/O 操作时、远程RPC 调用时，包括进行数据库操作时，这时候 CPU 就闲下来了，你可以利用多线程提高它的利用率。
经验公式如下
线程数 = 核数 * 期望 CPU 利用率 * 总时间(CPU计算时间+等待时间) / CPU 计算时间
例如 4 核 CPU 计算时间是 50% ，其它等待时间是 50%，期望 cpu 被 100% 利用，套用公式:
4 * 100% * 100% / 50% = 8
例如 4 核 CPU 计算时间是 10% ，其它等待时间是 90%，期望 cpu 被 100% 利用，套用公式:
4 * 100% * 100% / 10% = 40
Fork / join
原理
Fork/Join 是 JDK 1.7 加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型运算。
所谓的任务拆分，是将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。跟递归相关的一些计算，如归并排序、斐波那契数列、都可以用分治思想进行求解。
Fork/Join 在分治的基础上加入了多线程，可以把每个任务的分解和合并交给不同的线程来完成，进一步提升了运算效率。
Fork/Join 默认会创建与 cpu 核心数大小相同的线程池。
Fork/Join框架使用一个巧妙的算法来平衡线程的负载，称为工作窃取（work-stealing）算法。
假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。
工作窃取算法的优点是充分利用线程进行并行计算，并减少了线程间的竞争，其缺点是在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且消耗了更多的系统资源，比如创建多个线程和多个双端队列。
使用
Fork/Join内部大量运用了位操作和无锁算法。该框架主要涉及三大核心组件：ForkJoinPool（线程池）、ForkJoinTask（任务）、ForkJoinWorkerThread（工作线程），外加WorkQueue（任务队列）：
- ForkJoinPool：ExecutorService的实现类，负责工作线程的管理、任务队列的维护，以及控制整个任务调度流程；
- ForkJoinTask：Future接口的实现类，fork是其核心方法，用于分解任务并异步执行；而join方法在任务结果计算完毕之后才会运行，用来合并或返回计算结果；
- ForkJoinWorkerThread：Thread的子类，作为线程池中的工作线程（Worker）执行任务；
- WorkQueue：任务队列，用于保存任务
要定义一个任务，通常我们不需要字节继承ForkJoinTask，而只需要继承它的子类，Fork/Join框架提供了以下两个子类：
RecursiveAction：用于没有返回结果的任务。RecursiveTask：用于有返回结果的任务。
继承后实现它的compute方法，也就是具体执行的任务内容。
以一个对 1~n 之间的累加任务为例：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoinTest {
public static void main(String[] args) {
// 提交给 ForkJoinPool 来执行
ForkJoinPool pool = new ForkJoinPool(4);
System.out.println(pool.invoke(new AddTask1(5)));
}
}
@Slf4j
class AddTask1 extends RecursiveTask<Integer> {
int n;
public AddTask1(int n) {
this.n = n;
}
@Override
public String toString() {
return "{" + n + '}';
}
@Override
protected Integer compute() {
// 如果 n 已经为 1，可以求得结果了
if (n == 1) {
log.info("join() {}", n);
return n;
}
// 将任务进行拆分(fork)
AddTask1 t1 = new AddTask1(n - 1);
t1.fork();
log.info("fork() {} + {}", n, t1);
// 合并(join)结果
int result = n + t1.join();
log.info("join() {} + {} = {}", n, t1, result);
return result;
}
}
执行结果如下：
2023-07-05 22:21:05,194 - 0 INFO [ForkJoinPool-1-worker-7] up.cys.chapter07.AddTask1:47 - fork() 3 + {2}
2023-07-05 22:21:05,194 - 0 INFO [ForkJoinPool-1-worker-3] up.cys.chapter07.AddTask1:47 - fork() 5 + {4}
2023-07-05 22:21:05,194 - 0 INFO [ForkJoinPool-1-worker-5] up.cys.chapter07.AddTask1:47 - fork() 4 + {3}
2023-07-05 22:21:05,194 - 0 INFO [ForkJoinPool-1-worker-1] up.cys.chapter07.AddTask1:47 - fork() 2 + {1}
2023-07-05 22:21:05,203 - 9 INFO [ForkJoinPool-1-worker-7] up.cys.chapter07.AddTask1:40 - join() 1
2023-07-05 22:21:05,210 - 16 INFO [ForkJoinPool-1-worker-1] up.cys.chapter07.AddTask1:51 - join() 2 + {1} = 3
2023-07-05 22:21:05,211 - 17 INFO [ForkJoinPool-1-worker-7] up.cys.chapter07.AddTask1:51 - join() 3 + {2} = 6
2023-07-05 22:21:05,211 - 17 INFO [ForkJoinPool-1-worker-5] up.cys.chapter07.AddTask1:51 - join() 4 + {3} = 10
2023-07-05 22:21:05,211 - 17 INFO [ForkJoinPool-1-worker-3] up.cys.chapter07.AddTask1:51 - join() 5 + {4} = 15
15
用图来表示
因为上面我们计算n为5的任务时，还要等待n为4的任务的结果，同理后面也是，这样效率略低。针对上面的例子我们还可以来改进：给任务传两个值，计算两个值之间的累加，代码如下：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoinTest {
public static void main(String[] args) {
// 提交给 ForkJoinPool 来执行
ForkJoinPool pool = new ForkJoinPool(4);
System.out.println(pool.invoke(new AddTask1(1, 10)));
}
}
@Slf4j
class AddTask1 extends RecursiveTask<Integer> {
int begin;
int end;
public AddTask1(int begin, int end) {
this.begin = begin;
this.end = end;
}
@Override
public String toString() {
return "{" + begin + "," + end + '}';
}
@Override
protected Integer compute() {
// 5, 5
if (begin == end) {
log.debug("join() {}", begin);
return begin;
}
// 4, 5
if (end - begin == 1) {
log.debug("join() {} + {} = {}", begin, end, end + begin);
return end + begin;
}
// 1 5
int mid = (end + begin) / 2; // 3
// 将任务进行拆分(fork)
AddTask1 t1 = new AddTask1(begin, mid); // 1,3
t1.fork();
AddTask1 t2 = new AddTask1(mid + 1, end); // 4, 5
t2.fork();
log.info("fork() {} + {} = ?", t1, t2);
// 合并(join)结果
int result = t1.join() + t2.join();
log.info("join() {} + {} = {}", t1, t2, result);
return result;
}
}
执行结果如下：
2023-07-07 20:17:13,256 - 0 INFO [ForkJoinPool-1-worker-5] up.cys.chapter07.AddTask1:61 - fork() {1,3} + {4,5} = ?
2023-07-07 20:17:13,277 - 21 INFO [ForkJoinPool-1-worker-3] up.cys.chapter07.AddTask1:61 - fork() {1,5} + {6,10} = ?
2023-07-07 20:17:13,266 - 10 INFO [ForkJoinPool-1-worker-7] up.cys.chapter07.AddTask1:61 - fork() {6,8} + {9,10} = ?
2023-07-07 20:17:13,256 - 0 INFO [ForkJoinPool-1-worker-1] up.cys.chapter07.AddTask1:61 - fork() {6,7} + {8,8} = ?
2023-07-07 20:17:13,311 - 55 INFO [ForkJoinPool-1-worker-5] up.cys.chapter07.AddTask1:61 - fork() {1,2} + {3,3} = ?
2023-07-07 20:17:13,318 - 62 INFO [ForkJoinPool-1-worker-1] up.cys.chapter07.AddTask1:65 - join() {6,7} + {8,8} = 21
2023-07-07 20:17:13,319 - 63 INFO [ForkJoinPool-1-worker-5] up.cys.chapter07.AddTask1:65 - join() {1,2} + {3,3} = 6
2023-07-07 20:17:13,320 - 64 INFO [ForkJoinPool-1-worker-7] up.cys.chapter07.AddTask1:65 - join() {6,8} + {9,10} = 40
2023-07-07 20:17:13,320 - 64 INFO [ForkJoinPool-1-worker-5] up.cys.chapter07.AddTask1:65 - join() {1,3} + {4,5} = 15
2023-07-07 20:17:13,322 - 66 INFO [ForkJoinPool-1-worker-3] up.cys.chapter07.AddTask1:65 - join() {1,5} + {6,10} = 55
55
用图来表示如下：
参考：
https://redspider.gitbook.io/concurrent/di-san-pian-jdk-gong-ju-pian/12
https://blog.csdn.net/weixin_49561445/article/details/120597781
6806
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
