1、线程介绍

1.1 线程介绍

• POSIX Pthreads：可以作为用户或内核库提供，作为 POSIX 标准的扩展

• Win32 线程：用于 Window 操作系统的内核级线程库

• Java 线程：Java 线程 API 通常采用宿主系统的线程库来实现，也就是说在 Win 系统上，Java 线程 API 通常采用 Win API 来实现，在 UNIX 类系统上，采用 Pthread 来实现。

1.2 创建线程

• 实现 Runnable 接口，这种方式没有返回结果。

• 实现 Callable 接口，这种方式有返回结果，一般需要配合 FutureTask 使用。

• 继承 Thread 类。Thread 类实现了 Runnable 接口，所以直接重写 run() 方法即可。这种方式的优点是：如果需要访问当前线程的 API 方法，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

1.3 线程的状态切换

1. 初始(NEW)：新创建了一个线程对象，但还没有调用 start()方法。

2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为 运行。
1. 线程对象创建后，其他线程（比如main线程）调用了该对象的 start() 方法。该状态的线程位于可运行线程池中，等待被线程调度选中获取CPU的使用权，此时处于就绪状态（ready）。
2. 就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

3. 阻塞(BLOCKED)：表示线程阻塞于锁。一般是线程阻塞在进入 synchronized关键字修饰的方法或代码块(获取锁)时的状态。此时线程进入同步队列（SynchronizedQueue）。

4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。该状态的线程必须被显式地唤醒，否则会处于无限期等待的状态。此时线程进入等待队列（WatiQueue）。

5. 超时等待(TIMED_WAITING)：状态类似于 WAITING，但不同于 WAITING，它可以在指定的时间后自行返回。此时线程进入等待队列（WatiQueue）。

6. 终止(TERMINATED)：表示该线程已经执行完毕。

1.4 线程的优先级

1.5 线程API介绍

1.5.1 Thread类

• start()：线程被创建后就进入了 NEW 状态。调用线程的 start() 方法，线程就进入 RUNNABLE 状态。RUNNABLE 状态的线程不一定在运行，有可能处于 READY 状态，也有可能处于 RUNNING 状态，这主要看是否被调度器调度运行。

• yield() ：yield() 是静态方法。当前线程调用后主动放弃 CPU 时间片，由 RUNNING 状态变为 READY 状态，不释放锁资源，线程调度器会再次选择线程。yield() 的作用是让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证 yield() 达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。我们日常编码中其实很少会用到 yield() 方法，在并发工具类中倒是有被大量使用。

• sleep(long millis) ：sleep(long millis)是静态方法，当前线程调用后进入 TIMED_WAITING 状态，不释放锁资源，millis 后线程自动苏醒进入 READY 状态。

sleep(long millis) 和 yield() 的作用都是当前线程让出 CPU 资源让其他线程执行，都是静态方法，而且都不释放锁资源，区别是

1. 调用后线程状态不一致：调用 sleep(long millis) 后线程变成 TIMED_WAITING 状态，调用yield() 后线程变成 READY 状态。

2. sleep(long millis) 可以设置超时时间，yield() 不能设置超时时间。

• join()/join(long millis) ：作用是让主线程阻塞等待子线程的终止，使用方法是当前线程里调用其他线程的 join()/join(long millis)
• 如果是调用join()，被调用线程进入 WAITING 状态，等待其他线程执行完毕或者 millis 时间到，当前线程一般情况下进入 RUNNABLE 状态，也有可能进入 BLOCKED 状态。
• 如果是调用 join(long millis) ，被调用线程进入 TIMED_WAITING 状态，等待其他线程执行完毕或者 millis 时间到，当前线程一般情况下进入 RUNNABLE 状态，也有可能进入 BLOCKED 状态。
• 线程之所以有可能进入BLOCKED 状态，是因为 join() 是基于 wait() 实现的，Thread 类线程执行完 run()方法后，会自动执行 notifyAll() 方法。
• 注意 join() 会释放被调用的 Thread 实例的对象锁，但不会释放其它对象锁（包括 main 线程）。

• interrupt()：调用一个线程的 interrupt() 可以中断该线程，如果该线程处于 BLOCKED、WAITING 或者 TIME_WAITING 状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。

1.5.2 Object类

• wait() ：当前线程调用某个对象的 wait() 后，线程状态由 RUNNING 变为 WAITING，并释放该对象的锁资源，并将当前线程放置到对象的等待队列。

• notify() ：调用某个对象的 notify()，随机唤醒在该对象上等待的线程。等待线程不一定会立刻从 wait() 返回，需要调用 notify() 的线程释放了锁，等待线程获得了锁之后才会从 wait() 返回。

• notifyAll() ：调用某个对象的 notifyAll()，唤醒在该对象上等待的所有线程。其他基本同 notify() 。

1. 获取对象的锁。

2. 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。

3. 条件满足则执行对应的逻辑。

1. Thread-2 线程执行上述代码时，对象 obj 会被上一把锁，这是一把重量级锁，obj 对象头的 Mark Word 字段指向了操作系统创建的 Monitor 对象引用地址。

2. Monitor 对象只能有一个 Owner，此时如果有其它线程如 Thread-3 或 Thread-4 线程要获取这把锁就要进入 Monitor 对象的同步队列 EntryList 中，等待 Thread2 释放锁。

3. Thread-2 拿到 obj 对象锁之后，如果主动释放锁（通过调用 obj.wait()），Thread-2 变成 WAITING 状态，进入 Monitor 对象的等待队列 WaitSet 中，等待其他线程调用 obj.notify() 来唤醒它。

1.5.3 LockSupport类

• park(): 阻塞当前线程，如果调用 unpark(Thread thread) 方法或者当前线程被中断，才能从 park() 方法返回。

• parkNanos(long nanos): 阻塞当前线程，最长不超过 nanos 纳秒，返回条件在 park() 的基础上增加了超时返回。

• parkUntil(long deadline): 阻塞当前线程，知道 deadline 时间 （从 1970 年开始到 deadline 时间的毫秒数）。

• unpark(Thread thread): 唤醒处于阻塞状态的线程 thread。

• park(Object blocker): 阻塞当前线程，blocker 用来标识当前线程在等待的对象，该对象主要用于问题排查和系统监控。

• parkNanos(Object blocker, long nanos): 比 park(Object blocker) 增加一个超时时间。

• parkUntil(Object blocker, long deadline): 比 parkUntil(long deadline) 多一个阻塞当前对象。

• LockSupport类使用了一种名为 Permit(许可) 的概念来做到阻塞和唤醒线程的功能。

• 每个线程都有一个 permit，permit 只有两个值 1 和 0，默认是 0。可以把 permit 看成是一种（ 0-1）信号量(Semaphore)，但与 Semaphore 不同的是，permit 的累加上限是 1。

• 因为 permit 默认是 0，当前线程 thread 调用 park()方法，thread 线程就会阻塞。

• 直到其他线程调用 unpark(thread) 方法后，就会将 thread 线程的 permit 设置成 1（注意多次调用 unpark方法，不会累加，permit 值还是 1），会自动唤醒 thread 线程。

注意：唤醒两次后阻塞两次，最终结果还会阻塞线程。

因为 permit 的数量最多为 1，连续调用两次 unpark 和调用一次 unpark 效果一样，只会增加一个 permit。而调用两次 park 却需要消费两个 permit 。permit 数量不够，所以线程还是会被阻塞。

1.5.4 Condition类

• await()：当前线程进入等待状态直到被通知（signal）或中断。如果当前等待线程从 await() 方法返回，那么表明该线程已经获取了Condition 对象所对应的锁。当前线程从 await() 方法返回的情况包括：1、其他线程调用该 Condition 的 signal() 或 signalAll() 方法 ，而当前线程被选中唤醒；2、其他线程调用 Interrupt()方法中断当前线程

• awaitUninterruptibly()：当前线程进入等待状态被通知，从方法返回名称上可以看出该方法对中断不敏感

• awaitNanos(long nanosTimeout)：当前线程进入等待状态直到被通知，中断或者超时。返回值表示剩余的时间，如果在 nanosTimeout 纳秒之前被唤醒，那么返回值就是 （nanosTimeout-实际耗时）。如果返回 0 或者负数，那么可以认定已经超时了

• awaitUntil(Date deadline)：当前线程进入等待状态知道被通知、中断或者到某一个时间。如果没有到指定时间就被通知，方法返回 true ，否则，表示到了指定时间，方法返回 false。

• signal()：唤醒一个等待在 Condition 上的线程，该线程从等待方法返回前必须获得与 Condition 相关的锁

• signalAll()：唤醒所有等待在 Condition 上的线程，能够从等待方法返回的线程必须获得与 Condition相关的锁

Object.wait() 、 LockSupport.park() 、 Condition.await() 的区别：

• Object.wait() 和 Condition.await() 需要获取锁，LockSupport.park()不需要获得锁就可以让线程进入 WAITING/TIMED_WAITING 状态，可以在任何地方执行，比前者更灵活，性能更好。

• Object.wait() 和 Condition.await() 需要捕获InterruptedException，LockSupport.park() 不需要捕获异常。

• Object.wait() 本身就是 native 方法，LockSupport.park() 底层调用了 Unsafe 的 native 方法，Condition.await() 底层使用 LockSupport 来实现。

1.5.5 线程状态转换过程

2、线程池介绍

• 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

• 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

3、Executor框架

严格意义上讲 Executor 并不是一个线程池，只是一个执行工具，真正的线程池接口是 ExecutorService。

• 任务(Runnable /Callable)。也就是工作单元，包括被执行任务需要实现的接口：Runnable 接口或者 Callable 接口；

• 任务的执行(Executor)。包括任务执行机制的核心接口 Executor，以及继承自 Executor 的 ExecutorService 接口。ExecutorService 接口有两个关键实现类：ThreadPoolExecutor 和 ScheduledThreadPoolExecutor。

• 异步计算的结果(Future)。包括 Future 接口及实现了 Future 接口的 FutureTask 类。

1. 主线程首先要创建实现 Runnable 或者 Callable 接口的任务对象。

2. 然后可以把创建完成的 Runnable/Callable 对象交给 ExecutorService 执行，有两种方式：
1. 使用 ExecutorService.execute（Runnable command）方法，这种方式没有返回结果。
2. 使用 ExecutorService.submit(Callable task) 方法，这种方式会返回一个 FutureTask 对象 。（由于 FutureTask 实现了 Runnable，我们也可以创建 FutureTask，然后直接交给 ExecutorService 执行。）主线程可以执行 FutureTask.get() 方法来等待任务执行完成，可以执行 FutureTask.cancel() 来取消此任务的执行。

execute 和 submit 的区别：

• submit 可以获取异常信息，execute 不能获取异常信息。

• submit 可以提交 Runnable 任务和 Callable 任务，如果提交的是 Callable 任务可以获取到任务返回值，execute 只能提交 Runnable 任务，不能获取任务返回值。

3.1 Runnable和Callable

3.2 Executor

• Executor 接口：Executor 框架的基础，只是一个执行器，只定义了 execute() 一个方法，将任务和任务的执行分离开来。

• ExecutorService 接口：真正的线程池接口，定义了 submit()、 shutdown() 等线程池功能。
• ThreadPoolExecutor ：AbstractExecutorService 实现了 Executor 接口，而 ThreadPoolExecutor 继承了 AbstractExecutorService 接口。ThreadPoolExecutor 是 ExecutorService 接口的默认实现类，是线程池的最核心实现类。

• ScheduledExecutorService 接口：定期任务线程池的接口，继承了 ExecutorService。
• ScheduledThreadPoolExecutor ：ScheduledExecutorService 接口的实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor 比 Timer 更灵活，功能更强大。

• Executors 工厂类：提供了常见配置线程池的方法，因为 ThreadPoolExecutor 的参数众多且意义重大，为了避免配置出错，才有了 Executors 工厂类。利用 Executors 可以基于 ThreadPoolExecutor 实现类快速创建线程池：
• FixedThreadPool：固定线程数的线程池。
• SingleThreadExecutor：单个线程的线程池。
• CachedThreadPool：根据需要创建新线程，大小无界的线程

3.2.1 ThreadPoolExecutor

• corePoolSize：核心线程池大小。当线程池中的线程数目达到 corePoolSize 后，就会把暂时无法处理的任务放到缓存队列当中。如果调用了 prestartAllCoreThreads() 或者 prestartCoreThread() 方法，会直接预先创建corePoolSize的线程；否则会等有任务来之后，才创建一个线程去执行任务。

• maximumPoolSize：最大线程池大小。表示在线程池中最多能创建多少个线程，如果运行中的线程超过了这个数字，那么相当于线程池已满，新来的任务会使用 RejectedExecutionHandler 进行处理。

• keepAliveTime：线程最大空闲时间。如果线程数超过 corePoolSize 且线程空闲时长超过 keepAliveTime，就会减少线程数维持在 corePoolSize 大小。

• unit：时间单位。参数 keepAliveTime 的时间单位。

• workQueue：线程等待队列。一个阻塞队列，用来存储等待执行的任务，如果当前对线程的需求超过了 corePoolSize 大小，才会放在这里。可供使用的阻塞队列有：
• LinkedBlockingQueue：链表实现的有界阻塞队列，最常用的阻塞队列。在初始化时指定一个大小，如果不指定就会使用默认大小为 Integer.MAX_VALUE 的容量。注意要配置一下队列大小，设置成有界队列。否则可能会把内存撑爆。用于 FixedThreadPool 和 SingleThreadExecutor。
• ArrayBlockingQueue：数组实现的有界队列。
• DelayQueue：延时队列。用于周期任务线程池中。
• PriorityBlockingQueue：优先级队列。
• SynchronousQueue：同步队列，用于 CachedThreadPool。

• threadFactory：线程创建工厂，主要用来创建线程，比如可以指定线程的名字。默认可以使用 Executors.defaultThreadFactory()。

• handler：拒绝策略。当线程池满了的时候，用于处理新任务的策略。可以通过实现 RejectedExecutionHandler 接口自定义拒绝策略，ThreadPoolExecutor 内部也提供了四种拒绝策略：
• AbortPolicy：这是默认的策略，直接抛出异常。
• CallerRunsPolicy：由调用者所在线程来运行任务。
• DiscardOldestPolicy：丢弃队列中最老的任务，并执行当前任务。
• DiscardPolicy：不处理，直接把当前任务丢弃。

1. 当任务量小于 corePoolSize 的时候，它会创建一个线程来执行此任务。

2. 当任务量大于 corePoolSize，并且没有空闲线程的时候，且线程池的线程数小于 maximumPoolSize，此时会将任务存到 workQueue 里面。

3. 当前任务量继续增大，并且 workQueue 已经满了，就创建线程来执行任务，直到线程数等于 maximumPoolSize。

4. 当 workQueue 已经满了，且线程数等于 maximumPoolSize，这时候就会对处理不过来的任务执行拒绝策略。

• shutDown()：把线程池的状态设置为 SHUTDOWN，然后中断所有没有正在执行任务的线程，而已经在执行任务的线程继续执行直到任务执行完毕。

• shutDownNow()：把当前线程池状态设为 STOP，尝试停止所有的正在执行或者暂停的线程，并返回等待执行的任务的列表。

3.2.2 Executors工具类

• FixedThreadPool：固定线程数的线程池。

• SingleThreadExecutor：单个线程的线程池。

• CachedThreadPool：根据需要创建新线程，大小无界的线程。

阿里巴巴开发手册不允许使用 Executors 去创建线程池，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

还有一种原因是FixedThreadPool 和 SingleThreadExecutor 的任务队列最大队列长度是 Integer.MAX_VALUE，约等于无限队列，可能会因为任务数量过多出现 OOM 问题；CachedThreadPool 允许创建的线程数量为 Integer.MAX_VALUE，约等于可以无限创建线程，可能会因为创建大量线程出现 OOM 问题。

• 把线程池最大线程数量 maxmumPoolSize 和核心线程池的数量 corePoolSize 设置为相等，值为 FixedThreadPool 时指定的参数 nThreads，所以线程数量是固定的。

• keepAliveTime 设置为0L，意味着多余的空闲线程会被立即终止。因为 maxmumPoolSize 和 corePoolSize 相等，所以这是个无效参数。

• 使用 LinkedBlockingQueue 作为阻塞队列，但是没有设置队列大小，默认为 Integer.MAX_VALUE，约等于无限队列，所以不会执行拒绝策略。所以 handler 也是个无效参数。由于使用无界队列，SingleThreadExecutor 不会拒绝任务，任务会一直添加到任务队列中，可能会因为任务数量过多出现 OOM 问题。

• corePoolSize 和 maximumPoolSize 被设置为1。其他参数与 FixedThreadPool 相同。

• corePoolSize 被设置为 0，maximumPoolSize 被设置为 Integer.MAX_VALUE，相当于无限，所以最大线程数不受限制。

• keepAliveTime 设置为 60L，意味着 CachedThreadPool 中的空闲线程等待新任务的最长时间为60秒。

• 使用没有容量的 SynchronousQueue 作为线程池的工作队列，但是因为 maximumPool 是无界的，如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新线程。可能会因为线程数量过多出现 OOM 问题。

3.2.3 ScheduledThreadPoolExecutor

• ScheduledThreadPoolExecutor：包含若干个线程的 ScheduledThreadPoolExecutor。

• SingleThreadScheduledExecutor：只包含一个线程的 ScheduledThreadPoolExecutor。

• corePoolSize 由使用者自行设置，maximumPoolSize 虽然被设置为 Integer.MAX_VALUE ，但是由于 DelayedWorkQueue 是无界队列，所以 maximumPoolSize 的大小没有意义，相当于无效参数。

• 待调度的任务（ScheduledFutureTask）放到一个DelayQueue，DelayQueue 封装了一个 PriorityQueue，这个 PriorityQueue 会对队列中的 ScheduledFutureTask 进行排序。排序时，time 小的排在前面（时间早的任务将被先执行）。

3.3 FutureTask

3.3.1 FutureTask使用

1. 能够中断执行中的任务。

2. 判断任务是否执行完成。

3. 获取任务执行完成后的结果。

1. get() 方法：
1. 当 FutureTask 处于未启动或者已启动的状态时，调用 get() 方法会将导致调用线程阻塞。
2. 当 FutureTask 处于已完成的状态时，调用 get() 方法会立即放回调用结果或者抛出异常。

2. cancel(...) 方法：
1. 当 FutureTask 处于未启动状态时，调用 cancel(...) 方法将导致线程永远不会被执行。
2. 当 FutureTask 处于已启动状态时，调用 cancel(true) 方法将以中断执行此任务的线程的方式来试图停止此任务；调用 cancel(false) 方法将不会对正在进行的任务产生任何影响。
3. 当 FutureTask 处于已完成状态时，调用 cancel(...) 方法将返回 false。

3.3.2 FutureTask原理

• NEW：表示是个新的任务或者还没被执行完的任务。这是初始状态。

• COMPLETING：任务已经执行完成或者执行任务的时候发生异常，但是任务执行结果或者异常原因还没有保存到outcome字段(outcome字段用来保存任务执行结果，如果发生异常，则用来保存异常原因)的时候，状态会从NEW变更到COMPLETING。但是这个状态会时间会比较短，属于中间状态。

• NORMAL：任务已经执行完成并且任务执行结果已经保存到outcome字段，状态会从COMPLETING转换到NORMAL。这是一个最终态。

• EXCEPTIONAL：任务执行发生异常并且异常原因已经保存到outcome字段中后，状态会从COMPLETING转换到EXCEPTIONAL。这是一个最终态。

• CANCELLED：任务还没开始执行或者已经开始执行但是还没有执行完成的时候，用户调用了cancel(false)方法取消任务且不中断任务执行线程，这个时候状态会从NEW转化为CANCELLED状态。这是一个最终态。

• INTERRUPTING：任务还没开始执行或者已经执行但是还没有执行完成的时候，用户调用了cancel(true)方法取消任务并且要中断任务执行线程但是还没有中断任务执行线程之前，状态会从NEW转化为INTERRUPTING。这是一个中间状态。

• INTERRUPTED：调用interrupt()中断任务执行线程之后状态会从INTERRUPTING转换到INTERRUPTED。这是一个最终态。

3.4 Executor实现原理

1. 如果当前运行的线程数小于核心线程数，那么就会新建一个线程来执行任务。

2. 如果当前运行的线程数等于或大于核心线程数，但是小于最大线程数，那么就把该任务放入到任务队列里等待执行。

3. 如果向任务队列投放任务失败（任务队列已经满了），但是当前运行的线程数是小于最大线程数的，就新建一个线程来执行任务。

4. 如果当前运行的线程数已经等同于最大线程数了，新建线程将会使当前运行的线程超出最大线程数，那么当前任务会被拒绝，拒绝策略会调用RejectedExecutionHandler.rejectedExecution()方法。

这里涉及到两个重要概念：

• Task：任务，实现了 Runnable接口，但是并没有通过 start 方法执行，而是被 Worker 调用了 run 方法来执行。

• Worker：线程，线程池会把每个线程封装成一个 Worker 对象。Worker 类本身既实现了 Runnable，又继承了 AQS，所以其既是一个可执行的线程，又可以达到锁的效果。

4、Fork/Join框架

4.1 Fork/Join使用

4.2 Fork/Join原理

• ForkJoinPool：线程池。

• ForkJoinTask：任务，但其本身是抽象类，通过会使用它的实现类：
• RecursiveAction：一个递归无结果的ForkJoinTask（没有返回值）。
• RecursiveTask：一个递归有结果的ForkJoinTask（有返回值）

• ForkJoinWorkerThread：负责执行任务。

1. ForkJoinPool 的每个工作线程都维护着一个工作队列（WorkQueue），这是一个双端队列（Deque），里面存放的对象是任务（ForkJoinTask）。

2. 每个工作线程在运行中产生新的任务（通常是因为调用了 fork()）时，会放入工作队列的队尾，并且工作线程在处理自己的工作队列时，使用的是 LIFO 方式，也就是说每次从队尾取出任务来执行。

3. 每个工作线程在处理自己的工作队列同时，会尝试窃取一个任务（或是来自于刚刚提交到 pool 的任务，或是来自于其他工作线程的工作队列），窃取的任务位于其他线程的工作队列的队首，也就是说工作线程在窃取其他工作线程的任务时，使用的是 FIFO 方式。

4. 在遇到 join() 时，如果需要 join 的任务尚未完成，则会先处理其他任务，并等待其完成。

5. 在既没有自己的任务，也没有可以窃取的任务时，进入休眠。

4.2.1 ForkJoinPool

4.2.2 ForkJoinTask

• NORMAL 已完成

• CANCELLED 被取消

• SIGNAL 信号

• EXCEPTIONAL 发生异常

• fork() 在当前线程运行的线程池中安排一个异步执行，简单的理解就是再创建一个子任，将任务通过 push 方法加入到当前工作线程的工作队列或者提交队列（外部非 ForkJoinWorkerThread 线程通过 submit、 execute方法提交的任务），等待被线程池调度执行，这是一个非阻塞的立即返回方法。

• join() 当任务完成的时候返回计算结果。
1. 检查调用 join() 的线程是否是 ForkJoinThread 线程。如果不是（例如 main 线程），则阻塞当前线程，等待任务完成。如果是，则不阻塞。
2. 查看任务的完成状态，如果已经完成，直接返回结果。
3. 如果任务尚未完成，但处于自己的工作队列内，则完成它。
4. 如果任务已经被其他的工作线程偷走，则窃取这个小偷的工作队列内的任务（以 FIFO 方式），执行，以期帮助它早日完成欲 join 的任务。
5. 如果偷走任务的小偷也已经把自己的任务全部做完，正在等待需要 join 的任务时，则找到小偷的小偷，帮助它完成它的任务。
6. 递归地执行第5步。

• invoke() 开始执行任务，如果必要，等待计算完成。

4.2.3 ForkJoinWorkerThread