Fork/Join框架原理解析

1、概述

 

Fork/Join Pool采用优良的设计、代码实现和硬件原子操作机制等多种思路保证其执行性能。其中包括（但不限于）：计算资源共享、高性能队列、避免伪共享、工作窃取机制等。本文（以及后续文章）试图和读者一起分析JDK1.8中Fork/Join Pool的源代码实现，去理解Fork/Join Pool是怎样工作的。当然这里要说明一下，起初本人在决定阅读Fork/Join归并计算相关类的源代码时（ForkJoinPool、WorkQueue、ForkJoinTask、RecursiveTask、ForkJoinWorkerThread等），并不觉得这部分代码比起LinkedList这样的类来说有多少难度， 但其中大量使用位运算和位运算技巧，有大量Unsafe原子操作。博主能力有限，确实不能在短时间内将所有代码一一详细解读，所以也希望各位读者能帮助笔者一同完善。

2、要点

2-1. Fork/Join Pool实例化

实际上在之前文章中给出的Fork/Join Pool使用实例中，我们使用的new ForkJoinPool()或者new ForkJoinPool(N)这些方式来进行操作，这并不是ForkJoinPool作者Doug Lea推荐的使用方式。在ForkJoinPool主类的注释说明中，有这样一句话：

A static commonPool() is available and appropriate for most applications. The common pool is used by any ForkJoinTask that is not explicitly submitted to a specified pool.
Using the common pool normally reduces resource usage (its threads are slowly reclaimed during periods of non-use, and reinstated upon subsequent use).

以上描述大致的中文解释是：ForkJoinPools类有一个静态方法commonPool()，这个静态方法所获得的ForkJoinPools实例是由整个应用进程共享的，并且它适合绝大多数的应用系统场景。使用commonPool通常可以帮助应用程序中多种需要进行归并计算的任务共享计算资源，从而使后者发挥最大作用（ForkJoinPools中的工作线程在闲置时会被缓慢回收，并在随后需要使用时被恢复），而这种获取ForkJoinPools实例的方式，才是Doug Lea推荐的使用方式。代码如下：

 

  1. ......
  2. ForkJoinPool commonPool =  ForkJoinPool.commonPool();
  3. ......

通过阅读ForkJoinPool的代码我们可以发现ForkJoinPool中如何完成commonPool的初始化：、

  1. static {
  2.   ......
  3.   common = java.security.AccessController.doPrivileged
  4.             (new java.security.PrivilegedAction<ForkJoinPool>() {
  5.                 public ForkJoinPool run() { return makeCommonPool(); }});
  6.   // report 1 even if threads disabled
  7.   int par = common.config & SMASK; 
  8.   commonParallelism = par > 0 ? par : 1;
  9.   ......
  10. }
  11.  
  12. ......
  13.  
  14. // 这是主要的创建过程
  15. private static ForkJoinPool makeCommonPool() {
  16.    int parallelism = -1;
  17.    ForkJoinWorkerThreadFactory factory = null;
  18.    UncaughtExceptionHandler handler = null;
  19.    // 可以通过在java程序启动时，指定这些参数的方式
  20.    // 来完成并行等级，线程工厂，异常处理类的指定工作
  21.    try {
  22.        // 首先确认技术人员在启动应用程序时，是否指定了这些参数，来控制CommonPool的创建过程
  23.        // ignore exceptions in accessing/parsing properties
  24.        String pp =
  25.        System.getProperty("java.util.concurrent.ForkJoinPool.common.parallelism");
  26.        String fp = 
  27.        System.getProperty("java.util.concurrent.ForkJoinPool.common.threadFactory");
  28.        String hp =
  29.        System.getProperty("java.util.concurrent.ForkJoinPool.common.exceptionHandler");
  30.        if (pp != null)
  31.            parallelism = Integer.parseInt(pp);
  32.        if (fp != null)
  33.            factory = ((ForkJoinWorkerThreadFactory)ClassLoader.getSystemClassLoader().loadClass(fp).newInstance());
  34.        if (hp != null)
  35.            handler = ((UncaughtExceptionHandler)ClassLoader.getSystemClassLoader().loadClass(hp).newInstance());
  36.    } catch (Exception ignore) {
  37.  
  38.    }
  39.  
  40.    // 没有在启动时指定以上参数也没关系，java会启动默认参数
  41.    if (factory == null) {
  42.        // 如果当前没有启动SecurityManager，安全策略管理器
  43.        // 这时使用defaultForkJoinWorkerThreadFactory这个工厂对象
  44.        // 它是java.util.concurrent.ForkJoinPool.DefaultForkJoinWorkerThreadFactory这个类的实例
  45.        if (System.getSecurityManager() == null)
  46.            factory = defaultForkJoinWorkerThreadFactory;
  47.        else 
  48.            // use security-managed default
  49.            factory = new InnocuousForkJoinWorkerThreadFactory();
  50.    }
  51.  
  52.    // 如果并行等级小于0，并且当前应用程序可用CPU内核数为1
  53.    // 那么设定parallelism并行等级为1
  54.    if (parallelism < 0 && // default 1 less than #cores
  55.        (parallelism = Runtime.getRuntime().availableProcessors() - 1) <= 0)
  56.        parallelism = 1;
  57.    if (parallelism > MAX_CAP)
  58.        parallelism = MAX_CAP;
  59.  
  60.    // 最后使用这个构造函数初始化commonPool
  61.    return new ForkJoinPool(parallelism, factory, handler, LIFO_QUEUE, "ForkJoinPool.commonPool-worker-");
  62. }

以上代码片段中的中文注释是笔者加的，而英文注释是源代码自带的。对commonPool的初始化过程有Java security安全策略框架参与，doPrivileged方法为排除Java security安全策略框架的权限检查，而SecurityManager是Java security安全策略框架的管理器。一般情况下Java应用程序不会自动启动安全管理器，不过读者可以在Java应用程序启动时，使用-Djava.security.manager参数启动SecurityManager，或者在你的代码中通过System.setSecurityManager()方法显式设定一个。

当然，除了使用ForkJoinPool提供的commpool对象外，读者也可以直接通过ForkJoinPool提供的三种构造函数直接完成实例化，这三个可以同的构造分别是（以上构造函数的使用意义已经在之前的文章中讨论过了，这里就不再赘述了）：

  1. public ForkJoinPool() {
  2.     ......
  3. }
  4.  
  5. public ForkJoinPool(int parallelism) {
  6.     ......
  7. }
  8.  
  9. public ForkJoinPool(int parallelism, ForkJoinWorkerThreadFactory factory,
  10.                     UncaughtExceptionHandler handler, boolean asyncMode) {
  11.     ......
  12. }

2-2. 工作线程和工作队列

在本小节中我们主要讨论ForkJoinPool中处理ForkJoinTask任务及其子任务的情况，而ForkJoinPool处理Runnable或者Callable类型任务的情况将在后文讨论。ForkJoinPool中主要的工作线程，采用ForkJoinWorkerThread定义，其中有两个主要属性pool和workQueue：

  1. public class ForkJoinWorkerThread extends Thread {
  2.     ......
  3.     // the pool this thread works in
  4.     final ForkJoinPool pool;
  5.     // work-stealing mechanics
  6.     final ForkJoinPool.WorkQueue workQueue;
  7.     ......
  8. }

pool属性表示这个进行归并计算的线程所属的ForkJoinPool实例，workQueue属性是java.util.concurrent.ForkJoinPool.WorkQueue这个类的实例，它表示这个线程所使用的子任务待执行队列，而且可以被其它工作线程偷取任务。后者的内部是一个数组结构，并使用一些关键属性记录这个队列的实时状态，更具体的来说这个WorkQueue**是一个双端队列**。

这里写图片描述

Java中还有一组类似的双端队列顶层接口java.util.Deque、java.util.concurrent.BlockingDeque，但应该是出于实现细节的考虑，WorkQueue这个双端队列并没有实现这些接口。所谓双端队列，就是说队列中的元素（ForkJoinTask任务及其子任务）可以从一端入队出队，还可以从另一端入队出队。这个双端队列将用于支持ForkJoinPool的两种异步模型（asyncMode）：后进先出（LIFO_QUEUE）和先进先出（FIFO_QUEUE）。以下代码片段示例了WorkQueue类中定义的一些重要属性：

  1. ......
  2. static final class WorkQueue {
  3.     ......
  4.     // 队列状态
  5.     volatile int qlock;        // 1: locked, < 0: terminate; else 0
  6.     // 下一个出队元素的索引位（主要是为线程窃取准备的索引位置）
  7.     volatile int base;         // index of next slot for poll
  8.     // 为下一个入队元素准备的索引位
  9.     int top;                   // index of next slot for push
  10.     // 队列中使用数组存储元素
  11.     ForkJoinTask<?>[] array;   // the elements (initially unallocated)
  12.     // 队列所属的ForkJoinPool（可能为空）
  13.     // 注意，一个ForkJoinPool中会有多个执行线程，还会有比执行线程更多的（或一样多的）队列
  14.     final ForkJoinPool pool;   // the containing pool (may be null)
  15.     // 这个队列所属的归并计算工作线程。注意，工作队列也可能不属于任何工作线程
  16.     final ForkJoinWorkerThread owner; // owning thread or null if shared
  17.     // 记录当前正在进行join等待的其它任务
  18.     volatile ForkJoinTask<?> currentJoin;  // task being joined in awaitJoin
  19.     // 当前正在偷取的任务
  20.     volatile ForkJoinTask<?> currentSteal; // mainly used by helpStealer
  21.     ......
  22. }
  23. ......

当ForkJoinWorkerThread需要向双端队列中放入一个新的待执行子任务时，会调用WorkQueue中的push方法。我们来看看这个方法的主要执行过程（请注意，源代码来自JDK1.8，它和JDK1.7中的实现有显著不同）：

  1. /**
  2.  * Pushes a task. Call only by owner in unshared queues.  (The
  3.  * shared-queue version is embedded in method externalPush.)
  4.  */
  5. final void push(ForkJoinTask<?> task) {
  6.     ForkJoinTask<?>[] a; ForkJoinPool p;
  7.     int b = base, s = top, n;
  8.     // 请注意，在执行task.fork时，触发push情况下，array不会为null
  9.     // 因为在这之前workqueue中的array已经完成了初始化（在工作线程初始化时就完成了）
  10.     if ((a = array) != null) {
  11.     int m = a.length - 1;     // fenced write for task visibility
  12.     // U常量是java底层的sun.misc.Unsafe操作类
  13.     // 这个类提供硬件级别的原子操作
  14.     // putOrderedObject方法在指定的对象a中，指定的内存偏移量的位置，赋予一个新的元素
  15.     U.putOrderedObject(a, ((m & s) << ASHIFT) + ABASE, task);
  16.     // putOrderedInt方法对当前指定的对象中的指定字段，进行赋值操作
  17.     // 这里的代码意义是将workQueue对象本身中的top标示的位置 + 1，
  18.     U.putOrderedInt(this, QTOP, s + 1);
  19.     if ((n = s - b) <= 1) {
  20.         if ((p = pool) != null)
  21.         // Tries to create or activate a worker if too few are active.
  22.         // signalWork方法的意义在于，在当前活动的工作线程过少的情况下，创建新的工作线程
  23.         p.signalWork(p.workQueues, this);
  24.     }
  25.     // 如果array的剩余空间不够了，则进行增加
  26.     else if (n >= m)
  27.         growArray();
  28.     }
  29. }

sun.misc.Unsafe操作类直接基于操作系统控制层在硬件层面上进行原子操作，它是ForkJoinPool高效性能的一大保证，类似的编程思路还体现在java.util.concurrent包中相当规模的类功能实现中。实际上sun.misc.Unsafe操作类在Java中有着举足轻重的地位，本专题的后续文章中会详细介绍sun.misc.Unsafe操作类，以及基于这个类实现的Java乐观锁机制。当ForkJoinWorkerThread需要从双端队列中取出下一个待执行子任务，就会根据设定的asyncMode调用双端队列的不同方法，代码概要如下所示：

  1. // 试图从指定的队列中取出下一个待执行任务
  2. final ForkJoinTask<?> nextTaskFor(WorkQueue w) {
  3.     for (ForkJoinTask<?> t;;) {
  4.         WorkQueue q; int b;
  5.         // 该方法试图从“w”这个队列获取下一个待处理子任务
  6.         if ((t = w.nextLocalTask()) != null)
  7.             return t;
  8.         // 如果没有获取到，则使用findNonEmptyStealQueue方法
  9.         // 随机得到一个元素非空，并且可以进行任务窃取的存在于ForkJoinPool中的其它队列
  10.         // 这个队列被记为“q”
  11.         if ((q = findNonEmptyStealQueue()) == null)
  12.             return null;
  13.         // 试图从“q”这个队列base位处取出待执行任务
  14.         if ((b = q.base) - q.top < 0 && (t = q.pollAt(b)) != null)
  15.             return t;
  16.     }
  17. }
  18.  
  19. ......
  20.  
  21. /**
  22.  * Takes next task, if one exists, in order specified by mode.
  23.  */
  24. final ForkJoinTask<?> nextLocalTask() {
  25.     // 如果asyncMode设定为后进先出（LIFO）
  26.     // 则使用pop()从双端队列的前端取出任务
  27.     // 否则就是先进先出模式（FIFO），使用poll()从双端队列的后端取出任务
  28.     return (config & FIFO_QUEUE) == 0 ? pop() : poll();
  29. }
  30. ......

2-3. ForkJoinPool中的队列

那么ForkJoinPool是怎样创建队列的呢？请看如下两段源代码片段：

  1. /**
  2.  * Tries to add the given task to a submission queue at
  3.  * submitter's current queue. Only the (vastly) most common path
  4.  * is directly handled in this method, while screening for need
  5.  * for externalSubmit.
  6.  */
  7. // ForkJoinPool类中的方法
  8. // 该方法试图将一个任务提交到一个submission queue中，随机提交
  9. final void externalPush(ForkJoinTask<?> task) {
  10.     WorkQueue[] ws; WorkQueue q; int m;
  11.     // 取得一个随机探查数，可能为0也可能为其它数
  12.     int r = ThreadLocalRandom.getProbe();
  13.     // 获取当前ForkJoinPool的运行状态
  14.     int rs = runState;
  15.     // 最关键的操作在这里，详见后文说明
  16.     if ((ws = workQueues) != null && (m = (ws.length - 1)) >= 0 &&
  17.         (q = ws[m & r & SQMASK]) != null && r != 0 && rs > 0 &&
  18.         U.compareAndSwapInt(q, QLOCK, 0, 1)) {
  19.  
  20.         ForkJoinTask<?>[] a; int am, n, s;
  21.         if ((a = q.array) != null && (am = a.length - 1) > (n = (s = q.top) - q.base)) {
  22.         int j = ((am & s) << ASHIFT) + ABASE;
  23.         // 以下三个原子操作首先是将task放入队列
  24.         U.putOrderedObject(a, j, task);
  25.         // 然后将“q”这个submission queue的top标记+1
  26.         U.putOrderedInt(q, QTOP, s + 1);
  27.         // 最后解除这个submission queue的锁定状态
  28.         U.putIntVolatile(q, QLOCK, 0);
  29.  
  30.         // 如果条件成立，说明这时处于active的工作线程可能还不够
  31.         // 所以调用signalWork方法
  32.         if (n <= 1)
  33.             signalWork(ws, q);
  34.         return;
  35.         }
  36.     // 这里试图接除对这个submission queue的锁定状态
  37.     // 为什么会有两次接触呢？因为在之前代码中给队列加锁后，
  38.     // 可能队列的现有空间并不满足添加新的task的条件
  39.         U.compareAndSwapInt(q, QLOCK, 1, 0);
  40.     }
  41.  
  42.     externalSubmit(task);
  43. }
  44.  
  45. ......
  46.  
  47. /**
  48.  * Full version of externalPush, handling uncommon cases, as well
  49.  * as performing secondary initialization upon the first
  50.  * submission of the first task to the pool.  It also detects
  51.  * first submission by an external thread and creates a new shared
  52.  * queue if the one at index if empty or contended.
  53.  */
  54. // 以下是externalSubmit方法的部分代码，用于初始化ForkJoinPool中的队列
  55. private void externalSubmit(ForkJoinTask<?> task) {
  56.     ......
  57.     // initialize
  58.     // 如果条件成立，就说明当前ForkJoinPool类中，还没有任何队列，所以要进行队列初始化
  59.     else if ((rs & STARTED) == 0 ||  ((ws = workQueues) == null || (m = ws.length - 1) < 0)) {
  60.         int ns = 0;
  61.         rs = lockRunState();
  62.         try {
  63.             if ((rs & STARTED) == 0) {
  64.                 // 通过原子操作，完成“任务窃取次数”这个计数器的初始化
  65.                 U.compareAndSwapObject(this, STEALCOUNTER, null, new AtomicLong());
  66.                 // create workQueues array with size a power of two
  67.                 // 这段代码也非常有趣，详见后文的分析。
  68.                 int p = config & SMASK; // ensure at least 2 slots
  69.                 int n = (p > 1) ? p - 1 : 1;
  70.                 n |= n >>> 1; n |= n >>> 2;  n |= n >>> 4;
  71.                 n |= n >>> 8; n |= n >>> 16; n = (n + 1) << 1;
  72.                 workQueues = new WorkQueue[n];
  73.                 ns = STARTED;
  74.             }
  75.         } finally {
  76.             unlockRunState(rs, (rs & ~RSLOCK) | ns);
  77.         }
  78.     }
  79.     ......
  80. }

externalPush方法中的“q = ws[m & r & SQMASK]”代码非常重要。我们大致来分析一下作者的意图，首先m是ForkJoinPool中的WorkQueue数组长度减1，例如当前WorkQueue数组大小为16，那么m的值就为15；r是一个线程独立的随机数生成器，关于java.util.concurrent.ThreadLocalRandom类的功能和使用方式可参见其它资料；而SQMASK是一个常量，值为126 （0x7e）。以下是一种可能的计算过程和计算结果：

这里写图片描述

实际上任何数和126进行“与”运算，其结果只可能是0或者偶数，即0 、 2 、 4 、 6 、 8。也就是说以上代码中从名为“ws”的WorkQueue数组中，取出的元素只可能是第0个或者第偶数个队列。

我们再来看看以上代码给出的externalSubmit方法中，进行WorkQueue数组初始化的代码。当外部调用这通过submit、execute、invoke方法向ForkJoinPool提交一个计算任务时，会运行这段代码为ForkJoinPool创建多个WorkQueue并形成数组。其中以下代码片段用于确定这个即将创建的WorkQueue数组的大小

  1. ......
  2. // SMASK是一个常量
  3. static final int SMASK = 0xffff;
  4. ......
  5. // 这是config的来源
  6. // mode是ForkJoinPool构造函数中设定的asyncMode，如果为LIFO，则mode为0，否则为65536
  7. // parallelism 为技术人员设置的（或者程序自行设定的）并发等级
  8. this.config = (parallelism & SMASK) | mode;
  9. ......
  10. // ensure at least 2 slots
  11. int p = config & SMASK;
  12. // n这个变量就是要计算的WorkQueue数组的大小
  13. int n = (p > 1) ? p - 1 : 1;
  14. ......
  15. n |= n >>> 1; n |= n >>> 2;  n |= n >>> 4;
  16. n |= n >>> 8; n |= n >>> 16; n = (n + 1) << 1;
  17. ......

从以上整理的代码可以看出，最后确认ForkJoinPool中WorkQueue数组初始化大小的因素是名叫config的变量，而config变量又与构造ForkJoinPool时所传入的并发等级（parallelism）、异步模式（asyncMode）有关。在我们选择LIFO模式时，计算结果如下表所示（下表中的结果建立在mode = 0的前提下）：

parallelismnparallelismn
1424
3848
516616
716816
9321032
…321432
…321632
1764……

是的，计算结果“n”按照两倍规模进行扩展，并且在初始化时保证和并发级别设定的数量（parallelism）至少两倍的关系。这是为什么呢？这是因为ForkJoinPool中的这些WorkQueue和工作线程ForkJoinWorkerThread并不是一对一的关系，而是随时都有多余ForkJoinWorkerThread数量的WorkQueue元素。而这个ForkJoinPool中的WorkQueue数组中，索引位为非奇数的工作队列用于存储从外部提交到ForkJoinPool中的任务，也就是所谓的submissions queue；索引位为奇数的工作队列用于存储归并计算过程中等待处理的子任务，也就是task queue。

这里写图片描述

这样我们也就可以明白，ForkJoinPool中重写的toString()方法，是如何取得submissions、tasks、steals和running监控数据，请看以下toString()方法的源码片段：

  1. public String toString() {
  2.     ......
  3.     WorkQueue[] ws; WorkQueue w;
  4.     if ((ws = workQueues) != null) {
  5.         // 循环着，依次遍历当前ForkJoinPool中WorkQueue数组的每一个元素
  6.         for (int i = 0; i < ws.length; ++i) {
  7.         if ((w = ws[i]) != null) {
  8.             // 获取当前WorkQueue中元素的数量
  9.             // （WorkQueue也是使用数组方式存储这些元素）
  10.             int size = w.queueSize();
  11.             // 如果当前数组元素的索引位为非奇数
  12.             // 说明是submissions queue，这时submissions计数器发生累加
  13.             if ((i & 1) == 0)
  14.             qs += size;
  15.             else {
  16.             // 否则说明是task queue，这时tasks计数器增加
  17.             qt += size;
  18.             // 通过nsteals属性，获得这个task queue中任务被“窃取”的次数
  19.             st += w.nsteals;
  20.             // 如果条件成立，就说明当前task queue所对应的工作线程
  21.             // 没有被任何方式阻塞，所以running计数器增加
  22.             if (w.isApparentlyUnblocked())
  23.                 ++rc;
  24.             }
  25.         }
  26.         }
  27.     }
  28.     ......
  29.     return super.toString() +
  30.         ......
  31.         ", running = " + rc +
  32.         ", steals = " + st +
  33.         ", tasks = " + qt +
  34.         ", submissions = " + qs +
  35.         "]";
  36. }

注释比较详细，而且比起workqueue的入队出队逻辑和任务窃取逻辑，以上代码就是非常简单了。所以这里就不再赘述代码过程了。注意，以上代码分析基于JDK 1.8的源码分析，而与JDK1.7中ForkJoinPool的实现有较大差异。

2-5. ForkJoinPool工作监控

ForkJoinPool重写了toString()方法，以便技术人员在代码调试或者其它需要临时监控ForkJoinPool运行情况的场景下，轻松获取ForkJoinPool中的主要工作状态。以下运行效果展示了ForkJoinPool类的toString()方法打印的情况：

  1. **********************
  2. @2503dbd3[Running, parallelism = 6, size = 9, active = 7, running = 7, steals = 14, tasks = 224, submissions = 0]
  3. **********************
  4. @2503dbd3[Running, parallelism = 6, size = 9, active = 7, running = 7, steals = 14, tasks = 213, submissions = 0]
  5. **********************
  6. @2503dbd3[Running, parallelism = 6, size = 9, active = 7, running = 7, steals = 14, tasks = 164, submissions = 0]
  7. **********************
  8. @2503dbd3[Running, parallelism = 6, size = 9, active = 9, running = 9, steals = 22, tasks = 281, submissions = 0]
  9. **********************
  10. @2503dbd3[Running, parallelism = 6, size = 9, active = 8, running = 8, steals = 22, tasks = 212, submissions = 0]
  11. **********************
  12. @2503dbd3[Running, parallelism = 6, size = 9, active = 7, running = 7, steals = 22, tasks = 192, submissions = 0]
  13. **********************
  • parallelism：当前ForkJoinPool设定的并行级别
  • size：当前ForkJoinPool线程池内部的所有线程数量，这些线程可能处于阻塞状态（使用join方法引起的阻塞或者任务中其它会引起线程阻塞方法引起的阻塞），可能处于运行状态。
  • active：当前线程池内部，正在进行compute计算的线程（这些线程不代表没有被阻塞）。
  • running：当前线程池内部，正在进行compute计算并且没有被任何阻塞线程阻塞机制所影响的线程数量
  • steals：当前ForkJoinPool线程池内部各个work queue间发生的“工作窃取”操作的总次数。
  • tasks：当前ForkJoinPool线程池内部各个work queue中等待处理的子任务总数量。
  • submissions：通过submit方式或者其它方式提交到ForkJoinPool中，准备进行归并计算的但是ForkJoinPool还没有开始处理的任务（ForkJoinTask任务或者其子任务）数量。

这里要重点说明一下active和running两个返回信息的关系和区别：通常情况下active数量和running数量是一致的，因为正在运行归并计算子任务的线程，肯定是处于运行状态，否则它怎么进行计算呢？但是如果技术人员在进行归并计算的时候，主动阻塞了线程就另当别论了。例如技术人员在compute()方法中使用wait方法主动阻塞线程的情况：

  1. ......
  2. protected int[] compute() {
  3.     ......
  4.     // 让任务随机等待
  5.     // 因为要进行1亿次计算，大约设定百万分之1的概率强制阻塞
  6.     if(ThreadLocalRandom.current().nextFloat() < 0.000001f) {
  7.         try {
  8.             synchronized (this) {
  9.                 this.wait(1000);
  10.             } 
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace(System.out);
  13.         }
  14.     }
  15.     ......
  16. }
  17. ......

以上的代码在对1亿条数据数进行排序时，有百万分之一的概率阻塞排序子任务。在子任务进行归并计算时，可强制让计算线程阻塞1秒。这时我们再执行这个应用程序并且进行监控，那么以下可能就是我们会看到的监控信息了：

  1. **********************
  2. @2503dbd3[Running, parallelism = 4, size = 7, active = 5, running = 3, steals = 21, tasks = 154, submissions = 0]
  3. **********************
  4. @2503dbd3[Running, parallelism = 4, size = 7, active = 5, running = 0, steals = 21, tasks = 142, submissions = 0]
  5. **********************
  6. @2503dbd3[Running, parallelism = 4, size = 7, active = 5, running = 2, steals = 25, tasks = 131, submissions = 0]
  7. **********************
  8. @2503dbd3[Running, parallelism = 4, size = 7, active = 7, running = 2, steals = 28, tasks = 212, submissions = 0]
  9. **********************
  10. @2503dbd3[Running, parallelism = 4, size = 7, active = 7, running = 3, steals = 28, tasks = 216, submissions = 0]
  11. **********************
  12. @2503dbd3[Running, parallelism = 4, size = 7, active = 6, running = 0, steals = 28, tasks = 148, submissions = 0]
  13. **********************
  14. @2503dbd3[Running, parallelism = 4, size = 7, active = 5, running = 1, steals = 28, tasks = 142, submissions = 0]
  15. **********************

因为是随机概率，所以读者自行运行的监控效果和这里给出的监控效果是不同的。

注：本文转载自blog.csdn.net的华山拎壶冲的文章"https://blog.csdn.net/tyrroo/article/details/81483608"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！