ForkJoinPool

  1. ForkJoinPool 是一个运行 ForkJoinTask 任务、支持工作窃取和并行计算的线程池

核心参数+创建实例

  1.     // 工作者线程驻留任务队列索引位
  2.     static final int SWIDTH       = 16;
  3.     // 低 16 位掩码
  4.     static final int SMASK        = 0xffff;
  5.     // 最大并行度：#workers - 1
  6.     static final int MAX_CAP      = 0x7fff;
  7.     // 最大工作队列数、提交队列数
  8.     static final int SQMASK       = 0x007e;     
  10.     // 工作者线程需要唤醒信号
  11.     static final int UNSIGNALLED  = 1 << 31;       // must be negative
  12.     // 防止 ABA 问题的版本号
  13.     static final int SS_SEQ       = 1 << 16;
  14.     // 提交队列锁
  15.     static final int QLOCK        = 1;             
  17.     // 任务队列拥有所有者【驻留线程】
  18.     static final int OWNED        = 1;
  19.     // 任务是先进先出的
  20.     static final int FIFO         = 1 << 16;
  21.     // 线程池正在关闭
  22.     static final int SHUTDOWN     = 1 << 18;
  23.     // 线程池已经停止
  24.     static final int TERMINATED   = 1 << 19;
  25.     // 线程池正在停止
  26.     static final int STOP         = 1 << 31;       // must be negative
  27.     // 任务队列处于静止状态
  28.     static final int QUIET        = 1 << 30;
  29.     // 任务队列处于静止状态 && 驻留线程已经阻塞、需要唤醒信号
  30.     static final int DORMANT      = QUIET | UNSIGNALLED;
  32.     /**
  33.      *  工作者线程能在驻留的工作队列中一次性处理的最大任务数
  34.      */
  35.     static final int POLL_LIMIT = 1 << 10;
  37.     /**
  38.      *  默认的工作者线程工厂
  39.      */
  40.     public static final ForkJoinWorkerThreadFactory
  41.     defaultForkJoinWorkerThreadFactory;
  43.     /**
  44.      * Common (static) pool. 通用 ForkJoinPool
  45.      */
  46.     static final ForkJoinPool common;
  48.     /**
  49.      *  通用线程池的并行度
  50.      */
  51.     static final int COMMON_PARALLELISM;
  53.     /**
  54.      *  通用线程池最大补偿的工作线程数
  55.      */
  56.     private static final int COMMON_MAX_SPARES;
  58.     /**
  59.      *  线程池序列号，用于生成工作者线程名称
  60.      */
  61.     private static int poolNumberSequence;
  63.     /**
  64.      *  默认的工作者线程超时时间，以毫秒为单位，即 60 秒
  65.      */
  66.     private static final long DEFAULT_KEEPALIVE = 60_000L;
  68.     /**
  69.      * Undershoot tolerance for idle timeouts【超时微调】
  70.      */
  71.     private static final long TIMEOUT_SLOP = 20L;
  73.     private static final int DEFAULT_COMMON_MAX_SPARES = 256;
  75.     private static final int SEED_INCREMENT = 0x9e3779b9;
  77.     /**
  78.      * 64 位控制变量的组成，从高到低每 16 位一个单元
  79.      * RC: 正在运行的工作者线程数 - parallelism
  80.      * TC: 正在运行的工作者线程数 + 阻塞等待的工作者线程数 - parallelism
  81.      * SS: 版本号 + 最近阻塞的线程状态
  82.      * ID: 最近阻塞的工作者线程所在的工作队列索引
  83.      *
  84.      * ac 为负数：表示运行中的工作者线程不够
  85.      * tc 为负数：表示总的工作者线程不够
  86.      * sp != 0：表示有工作者线程在阻塞等待
  87.      */
  88.     private static final long SP_MASK    = 0xffffffffL;
  89.     private static final long UC_MASK    = ~SP_MASK;
  91.     private static final int  RC_SHIFT   = 48;
  92.     // 单个工作者线程计数，用于 RC
  93.     private static final long RC_UNIT    = 0x0001L << RC_SHIFT;
  94.     // 控制变量 48-64 位掩码
  95.     private static final long RC_MASK    = 0xffffL << RC_SHIFT;
  97.     private static final int  TC_SHIFT   = 32;
  98.     // 单个工作者线程计数，用于 TC
  99.     private static final long TC_UNIT    = 0x0001L << TC_SHIFT;
  100.     // 控制变量 32-48 位掩码
  101.     private static final long TC_MASK    = 0xffffL << TC_SHIFT;
  102.     // 尝试增加一个工作者线程，工作者线程数 < parallelism
  103.     private static final long ADD_WORKER = 0x0001L << TC_SHIFT + 15; // sign
  105.     // 工作者线程的窃取任务总数
  106.     volatile long stealCount;
  107.     // 工作者线程的空闲存活时间
  108.     final long keepAlive;
  109.     // 下一个工作队列索引
  110.     int indexSeed;
  111.     // 最大、最小线程数
  112.     final int bounds;
  113.     /**
  114.      * runstate：第 18、19、30、31 位
  115.      * queue mode：第 16 位
  116.      * parallelism：1-15 位，最大并行度为 1<<15-1
  117.      */
  118.     volatile int mode;
  119.     // 已注册的工作队列
  120.     WorkQueue[] workQueues;
  121.     // 工作者线程名称前缀，同时作为创建工作队列时的 synchronized 锁
  122.     final String workerNamePrefix;
  123.     // 创建工作者线程的工厂
  124.     final ForkJoinWorkerThreadFactory factory;
  125.     // 异常处理器
  126.     final UncaughtExceptionHandler ueh;
  127.     // 线程池饱和断言
  128.     final Predicate<? super ForkJoinPool> saturate;
  129.     // 核心控制变量
  130.     @jdk.internal.vm.annotation.Contended("fjpctl")
  131.     volatile long ctl;
  133.     public ForkJoinPool() {
  134.         /**
  135.          * 1）并行度为当前 JVM 的 CPU 总数 Runtime.getRuntime().availableProcessors()
  136.          * 2）使用默认的线程工厂
  137.          * 3）无异常处理器
  138.          * 4）工作队列的任务处理方式为 FILO
  139.          * 提交队列的任务处理方式为 FIFO，工作窃取
  140.          * 5）默认的核心工作者线程数为 0
  141.          * 6）默认的最大工作者线程数为 32767
  142.          * 7）默认工作者线程空闲超时时间为 60 秒
  143.          */
  144.         this(Math.min(MAX_CAP, Runtime.getRuntime().availableProcessors()),
  145.                 defaultForkJoinWorkerThreadFactory, null, false,
  146.                 0, MAX_CAP, 1, null, DEFAULT_KEEPALIVE, TimeUnit.MILLISECONDS);
  147.     }
  149.     /**
  150.      * @param parallelism 并行度【影响任务队列的长度和工作者线程数】
  151.      */
  152.     public ForkJoinPool(int parallelism) {
  153.         this(parallelism, defaultForkJoinWorkerThreadFactory, null, false,
  154.                 0, MAX_CAP, 1, null, DEFAULT_KEEPALIVE, TimeUnit.MILLISECONDS);
  155.     }
  157.     /**
  158.      * @param parallelism 并行度
  159.      * @param factory 工作者线程工厂
  160.      * @param handler 异常处理器
  161.      * @param asyncMode 任务处理模式
  162.      */
  163.     public ForkJoinPool(int parallelism,
  164.             ForkJoinWorkerThreadFactory factory,
  165.             UncaughtExceptionHandler handler,
  166.             boolean asyncMode) {
  167.         this(parallelism, factory, handler, asyncMode,
  168.                 0, MAX_CAP, 1, null, DEFAULT_KEEPALIVE, TimeUnit.MILLISECONDS);
  169.     }
  171.     /**
  172.      * @param parallelism ForkJoinPool 的并行度
  173.      * @param factory 工作者线程工厂
  174.      * @param handler 每个工作者线程的异常处理器
  175.      * @param asyncMode 工作队列的任务处理模式，默认是 false【FILO】，
  176.      *  消息模式下可以指定为 FIFO
  177.      * @param corePoolSize 核心工作者线程数，默认等于 parallelism
  178.      * @param maximumPoolSize 最大工作者线程数
  179.      * @param minimumRunnable 最小可用工作者线程数
  180.      * @param saturate 当线程池尝试创建 > maximumPoolSize 的工作者线程时，目标任务将被拒绝，
  181.      *  如果饱和断言返回 true，则该任务将继续执行
  182.      * @param keepAliveTime 工作线程的空闲超时时间
  183.      * @param unit keepAliveTime 的时间单位
  184.      * @since 9
  185.      */
  186.     public ForkJoinPool(int parallelism,
  187.             ForkJoinWorkerThreadFactory factory,
  188.             UncaughtExceptionHandler handler,
  189.             boolean asyncMode,
  190.             int corePoolSize,
  191.             int maximumPoolSize,
  192.             int minimumRunnable,
  193.             Predicate<? super ForkJoinPool> saturate,
  194.             long keepAliveTime,
  195.             TimeUnit unit) {
  196.         // check, encode, pack parameters
  197.         if (parallelism <= 0 || parallelism > MAX_CAP ||
  198.                 maximumPoolSize < parallelism || keepAliveTime <= 0L) {
  199.             throw new IllegalArgumentException();
  200.         }
  201.         if (factory == null) {
  202.             throw new NullPointerException();
  203.         }
  204.         // 计算超时时间
  205.         final long ms = Math.max(unit.toMillis(keepAliveTime), TIMEOUT_SLOP);
  206.         // 核心工作者线程数
  207.         final int corep = Math.min(Math.max(corePoolSize, parallelism), MAX_CAP);
  208.         // 计算 ctl
  209.         final long c = (long)-corep << TC_SHIFT & TC_MASK |
  210.                 (long)-parallelism << RC_SHIFT & RC_MASK;
  211.         // 计算 mode
  212.         final int m = parallelism | (asyncMode ? FIFO : 0);
  213.         final int maxSpares = Math.min(maximumPoolSize, MAX_CAP) - parallelism;
  214.         // 最小可用工作者线程数
  215.         final int minAvail = Math.min(Math.max(minimumRunnable, 0), MAX_CAP);
  216.         final int b = minAvail - parallelism & SMASK | maxSpares << SWIDTH;
  217.         int n = parallelism > 1 ? parallelism - 1 : 1; // at least 2 slots
  218.         n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16;
  219.         n = n + 1 << 1; // power of two, including space for submission queues
  221.         workerNamePrefix = "ForkJoinPool-" + nextPoolId() + "-worker-";
  222.         workQueues = new WorkQueue[n];
  223.         this.factory = factory;
  224.         ueh = handler;
  225.         this.saturate = saturate;
  226.         keepAlive = ms;
  227.         bounds = b;
  228.         mode = m;
  229.         ctl = c;
  230.         checkPermission();
  231.     }

提交任务

  1.     /**
  2.      *  往线程池中提交一个 Runnable 任务
  3.      */
  4.     @Override
  5.     @SuppressWarnings("unchecked")
  6.     public ForkJoinTask<?> submit(Runnable task) {
  7.         if (task == null) {
  8.             throw new NullPointerException();
  9.         }
  10.         // 如果 task 不是 ForkJoinTask 子类实例，则执行适配
  11.         return externalSubmit(task instanceof ForkJoinTask<?>
  12.         ? (ForkJoinTask<Void>) task // avoid re-wrap
  13.                 : new ForkJoinTask.AdaptedRunnableAction(task));
  14.     }
  16.     private <T> ForkJoinTask<T> externalSubmit(ForkJoinTask<T> task) {
  17.         Thread t; ForkJoinWorkerThread w; WorkQueue q;
  18.         if (task == null) {
  19.             throw new NullPointerException();
  20.         }
  21.         /**
  22.          * 1）如果任务提交线程是 ForkJoinWorkerThread 实例 &&
  23.          * 工作者线程关联的 ForkJoinPool 就是当前线程池 &&
  24.          * 工作者线程驻留的任务队列不为 null
  25.          * 则优先提交到自己的任务队列
  26.          */
  27.         if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread &&
  28.                 (w = (ForkJoinWorkerThread)t).pool == this &&
  29.                 (q = w.workQueue) != null) {
  30.             q.push(task);
  31.         // 2）将任务提交到共享提交队列
  32.         } else {
  33.             externalPush(task);
  34.         }
  35.         return task;
  36.     }
  38. ForkJoinTask#
  39.     /**
  40.      *  将 Runnable 任务适配为 ForkJoinTask 任务
  41.      */
  42.     static final class AdaptedRunnableAction extends ForkJoinTask<Void>
  43.     implements RunnableFuture<Void> {
  44.         /**
  45.          * 实际运行的任务
  46.          */
  47.         final Runnable runnable;
  48.         AdaptedRunnableAction(Runnable runnable) {
  49.             if (runnable == null) {
  50.                 throw new NullPointerException();
  51.             }
  52.             this.runnable = runnable;
  53.         }
  54.         @Override
  55.         public Void getRawResult() { return null; }
  56.         @Override
  57.         public void setRawResult(Void v) { }
  58.         // 运行 Runnable 任务
  59.         @Override
  60.         public boolean exec() { runnable.run(); return true; }
  61.         @Override
  62.         public void run() { invoke(); }
  63.         @Override
  64.         public String toString() {
  65.             return super.toString() + "[Wrapped task = " + runnable + "]";
  66.         }
  67.         private static final long serialVersionUID = 5232453952276885070L;
  68.     }
  70.     /**
  71.      *  将一个 ForkJoinTask 提交到一个提交队列中
  72.      */
  73.     final void externalPush(ForkJoinTask<?> task) {
  74.         int r;                                // initialize caller's probe
  75.         // 如果调用线程的探测值为 0
  76.         if ((r = ThreadLocalRandom.getProbe()) == 0) {
  77.             // 初始化线程局部随机数的探测值
  78.             ThreadLocalRandom.localInit();
  79.             /**
  80.              * 读取探测值【同一个线程只要不调用 advanceProbe 方法，探测值是不变的，
  81.              * 同一个线程提交任务时只要不出现竞争，就会将任务提交到相同的提交队列中】
  82.              */
  83.             r = ThreadLocalRandom.getProbe();
  84.         }
  85.         for (;;) {
  86.             // 读取 mode
  87.             final int md = mode;
  88.             int n;
  89.             // 读取工作队列
  90.             WorkQueue[] ws = workQueues;
  91.             // 线程池已经设置了 SHUTDOWN 标识 || 工作队列为空，则拒绝提交任务
  92.             if ((md & SHUTDOWN) != 0 || ws == null || (n = ws.length) <= 0) {
  93.                 throw new RejectedExecutionException();
  94.             } else {
  95.                 WorkQueue q;
  96.                 // push 是否添加成功，grow 是否需要进行扩容
  97.                 boolean push = false, grow = false;
  98.                 // 1）基于探测值掩码定位到指定索引的任务队列，如果该任务队列还未创建
  99.                 if ((q = ws[n - 1 & r & SQMASK]) == null) {
  100.                     // 读取工作者名称前缀
  101.                     final Object lock = workerNamePrefix;
  102.                     /**
  103.                      * 基于探测值、队列静止标识、非 FIFO 标识、无所有者标识
  104.                      * 生成队列 ID
  105.                      */
  106.                     final int qid = (r | QUIET) & ~(FIFO | OWNED);
  107.                     // 创建提交队列
  108.                     q = new WorkQueue(this, null);
  109.                     // 写入队列 ID
  110.                     q.id = qid;
  111.                     // 队列设置为静止状态
  112.                     q.source = QUIET;
  113.                     // 锁定队列
  114.                     q.phase = QLOCK;          // lock queue
  115.                     if (lock != null) {
  116.                         // 同步锁定队列
  117.                         synchronized (lock) { // lock pool to install
  118.                             int i;
  119.                             /**
  120.                              * 再次判断指定目标索引下的任务队列是否还为空，
  121.                              * 出现竞争时可能被其他线程提前写入
  122.                              */
  123.                             if ((ws = workQueues) != null &&
  124.                                     (n = ws.length) > 0 &&
  125.                                     ws[i = qid & n - 1 & SQMASK] == null) {
  126.                                 // 写入新建队列
  127.                                 ws[i] = q;
  128.                                 // 新建队列后需要扩容，并提交任务
  129.                                 push = grow = true;
  130.                             }
  131.                         }
  132.                     }
  133.                 }
  134.                 // 2）提交队列已经存在，则尝试获得共享锁
  135.                 else if (q.tryLockSharedQueue()) {
  136.                     // 获取锁成功，读取 base 和 top 值
  137.                     final int b = q.base, s = q.top;
  138.                     int al, d; ForkJoinTask<?>[] a;
  139.                     // 1）提交队列的任务数组不为空 && 任务数组未满
  140.                     if ((a = q.array) != null && (al = a.length) > 0 &&
  141.                             al - 1 + (d = b - s) > 0) {
  142.                         // 基于 top 值定位数组索引后写入任务
  143.                         a[al - 1 & s] = task;
  144.                         // 递增 top 值并写入
  145.                         q.top = s + 1;        // relaxed writes OK here
  146.                         // 释放共享锁
  147.                         q.phase = 0;
  148.                         // 队列中有多于 1 个任务
  149.                         if (d < 0 && q.base - s < -1)
  150.                         {
  151.                             break;            // no signal needed
  152.                         }
  153.                     // 数组已满则需要进行扩容
  154.                     } else {
  155.                         grow = true;
  156.                     }
  157.                     // 添加任务成功
  158.                     push = true;
  159.                 }
  160.                 if (push) {
  161.                     // 如果需要执行扩容
  162.                     if (grow) {
  163.                         try {
  164.                             // 执行任务队列的扩容
  165.                             q.growArray();
  166.                             // 读取 top 值
  167.                             final int s = q.top;
  168.                             int al; ForkJoinTask<?>[] a;
  169.                             if ((a = q.array) != null && (al = a.length) > 0) {
  170.                                 // 写入任务
  171.                                 a[al - 1 & s] = task;
  172.                                 // 递增 top 值并写入
  173.                                 q.top = s + 1;
  174.                             }
  175.                         } finally {
  176.                             // 释放共享锁
  177.                             q.phase = 0;
  178.                         }
  179.                     }
  180.                     // 添加任务成功，则尝试添加或唤醒工作者线程
  181.                     signalWork();
  182.                     break;
  183.                 } else {
  184.                     // 出现线程竞争时，重新生成探测值并进行重试
  185.                     r = ThreadLocalRandom.advanceProbe(r);
  186.                 }
  187.             }
  188.         }
  189.     }
  191.     static final class WorkQueue {
  192.         /**
  193.          *  任务数组的初始化容量为 8192
  194.          */
  195.         static final int INITIAL_QUEUE_CAPACITY = 1 << 13;
  196.         /**
  197.          *  任务数组的最大容量
  198.          */
  199.         static final int MAXIMUM_QUEUE_CAPACITY = 1 << 26; // 64M
  200. 	/**
  201. 	 *	值为负数：
  202. 	 *		1）(任务队列的 ID +累计版本号) | UNSIGNALLED
  203. 	 *		2）DORMANT：任务队列处于静止状态 && 驻留线程已经阻塞、需要唤醒信号
  204. 	 *	0：队列未锁定
  205. 	 *	1：队列被锁定
  206. 	 */
  207.         volatile int phase;
  208.         // 队列进入静止状态时的控制变量值，可能包含前一个静止的任务队列信息
  209.         int stackPred;
  210.         // 工作者线程窃取的任务数
  211.         int nsteals;
  212.         int id;                    // index, mode, tag
  213.         // 上一次窃取的工作队列 ID 或哨兵值
  214.         volatile int source;
  215.         // 执行 poll 操作的索引
  216.         volatile int base;
  217.         // 执行 push 或 pop 操作的索引
  218.         int top;
  219.         // 底层存储 ForkJoinTask 的数组
  220.         ForkJoinTask<?>[] array;
  221.         // 任务队列所在的线程池
  222.         final ForkJoinPool pool;
  223.         // 工作队列驻留的工作者线程，共享提交队列为 null
  224.         final ForkJoinWorkerThread owner; 
  226.         /**
  227.          * 尝试锁定共享提交队列
  228.          */
  229.         boolean tryLockSharedQueue() {
  230.             return PHASE.compareAndSet(this, 0, QLOCK);
  231.         }
  233.         /**
  234.          *  初始化队列或执行双倍扩容
  235.          */
  236.         ForkJoinTask<?>[] growArray() {
  237.             // 读取旧队列
  238.             final ForkJoinTask<?>[] oldA = array;
  239.             // 读取旧 size
  240.             final int oldSize = oldA != null ? oldA.length : 0;
  241.             // 计算新 size，初始化容量为 8192
  242.             final int size = oldSize > 0 ? oldSize << 1 : INITIAL_QUEUE_CAPACITY;
  243.             // size 小于 8192 或大于 64M
  244.             if (size < INITIAL_QUEUE_CAPACITY || size > MAXIMUM_QUEUE_CAPACITY) {
  245.                 // 扩容失败则抛出 RejectedExecutionException 异常，任务被拒绝
  246.                 throw new RejectedExecutionException("Queue capacity exceeded");
  247.             }
  248.             int oldMask, t, b;
  249.             // 基于新的 size 创建 ForkJoinTask 数组
  250.             final ForkJoinTask<?>[] a = array = new ForkJoinTask<?>[size];
  251.             // 旧数组中有任务存在，则执行迁移操作
  252.             if (oldA != null && (oldMask = oldSize - 1) > 0 &&
  253.                     (t = top) - (b = base) > 0) {
  254.                 // 计算新任务数组的 mask
  255.                 final int mask = size - 1;
  256.                 do { // emulate poll from old array, push to new array
  257.                     // 从 base 开始迁移任务
  258.                     final int index = b & oldMask;
  259.                     // 读取任务
  260.                     final ForkJoinTask<?> x = (ForkJoinTask<?>)
  261.                             QA.getAcquire(oldA, index);
  262.                     // 将旧数组中对应的 slot 置为 null
  263.                     if (x != null &&
  264.                             QA.compareAndSet(oldA, index, x, null)) {
  265.                         // 写入新数组
  266.                         a[b & mask] = x;
  267.                     }
  268.                 // 循环迁移
  269.                 } while (++b != t);
  270.                 VarHandle.releaseFence();
  271.             }
  272.             // 返回新数组
  273.             return a;
  274.         }
  275.     }
  277.     /**
  278.      *  尝试创建或唤醒一个工作者
  279.      */
  280.     final void signalWork() {
  281.         for (;;) {
  282.             long c; int sp; WorkQueue[] ws; int i; WorkQueue v;
  283.             // 1）活跃工作者线程数已经 >= 并行度
  284.             if ((c = ctl) >= 0L) {
  285.                 break;
  286.                 // 2）核心工作者线程未满 && 无空闲工作者线程
  287.             } else if ((sp = (int)c) == 0) {            // no idle workers
  288.                 if ((c & ADD_WORKER) != 0L) {
  289.                     // 尝试增加一个工作者线程
  290.                     tryAddWorker(c);
  291.                 }
  292.                 break;
  293.             }
  294.             // 3）workQueues 为 null 表示线程池未启动或已经终止
  295.             else if ((ws = workQueues) == null) {
  296.                 break;                                // unstarted/terminated
  297.                 // 4）线程池已经终止
  298.             } else if (ws.length <= (i = sp & SMASK)) {
  299.                 break;                                // terminated
  300.                 // 5）线程池正在终止，目标工作队列已经被回收
  301.             } else if ((v = ws[i]) == null) {
  302.                 break;                                // terminating
  303.                 // 6）核心工作者线程未满 && 有工作者线程静止或已经阻塞
  304.             } else {
  305.                 // 读取最近静止的工作队列 ID 及其工作队列索引
  306.                 final int np = sp & ~UNSIGNALLED;
  307.                 // 读取工作队列的 phase 值
  308.                 final int vp = v.phase;
  309.                 /**
  310.                  * 读取在这个工作队列静止或工作者线程阻塞前，
  311.                  * 上一个静止的工作者队列或阻塞的工作者线程所处的控制变量
  312.                  */
  313.                 final long nc = v.stackPred & SP_MASK | UC_MASK & c + RC_UNIT;
  314.                 // 读取工作队列驻留线程
  315.                 final Thread vt = v.owner;
  316.                 // 如果当前工作队列是最近静止的或其工作者线程是最近阻塞的，则尝试恢复为静止之前的控制变量
  317.                 if (sp == vp && CTL.compareAndSet(this, c, nc)) {
  318.                     // 写入 phase 值
  319.                     v.phase = np;
  320.                     // 如果 source 为 DORMANT【工作者线程阻塞前一刻写入】
  321.                     if (v.source < 0) {
  322.                         // 唤醒阻塞的工作者线程
  323.                         LockSupport.unpark(vt);
  324.                     }
  325.                     break;
  326.                 }
  327.             }
  328.         }
  329.     }
  331.     /**
  332.      *  尝试增加一个工作者线程
  333.      * Tries to add one worker, incrementing ctl counts before doing
  334.      * so, relying on createWorker to back out on failure.
  335.      */
  336.     private void tryAddWorker(long c) {
  337.         do {
  338.             // 活跃工作者线程数和总的工作者线程数，递增 1
  339.             final long nc = RC_MASK & c + RC_UNIT |
  340.                     TC_MASK & c + TC_UNIT;
  341.             // 如果控制变量未更新 && 原子更新当前控制变量成功
  342.             if (ctl == c && CTL.compareAndSet(this, c, nc)) {
  343.                 // 创建一个新的工作者线程
  344.                 createWorker();
  345.                 break;
  346.             }
  347.             // 出现竞争，则重新判断并重试
  348.         } while (((c = ctl) & ADD_WORKER) != 0L && (int)c == 0);
  349.     }
  351.     /**
  352.      *  尝试创建并启动一个新的工作者线程
  353.      */
  354.     private boolean createWorker() {
  355.         // 读取工作者线程工厂
  356.         final ForkJoinWorkerThreadFactory fac = factory;
  357.         Throwable ex = null;
  358.         ForkJoinWorkerThread wt = null;
  359.         try {
  360.             // 创建一个新的工作者线程
  361.             if (fac != null && (wt = fac.newThread(this)) != null) {
  362.                 // 启动工作线程
  363.                 wt.start();
  364.                 return true;
  365.             }
  366.         } catch (final Throwable rex) {
  367.             ex = rex;
  368.         }
  369.         // 创建失败或启动失败，则注销当前工作者
  370.         deregisterWorker(wt, ex);
  371.         return false;
  372.     }
  374.     final void deregisterWorker(ForkJoinWorkerThread wt, Throwable ex) {
  375.         WorkQueue w = null;
  376.         int phase = 0;
  377.         // 目标工作者线程不为 null && 任务队列不为 null
  378.         if (wt != null && (w = wt.workQueue) != null) {
  379.             final Object lock = workerNamePrefix;
  380.             // 计算窃取任务数
  381.             final long ns = w.nsteals & 0xffffffffL;
  382.             // 计算工作队列索引
  383.             final int idx = w.id & SMASK;
  384.             if (lock != null) {
  385.                 WorkQueue[] ws;                       // remove index from array
  386.                 synchronized (lock) {
  387.                     // 将工作者线程驻留的任务队列回收
  388.                     if ((ws = workQueues) != null && ws.length > idx &&
  389.                             ws[idx] == w) {
  390.                         ws[idx] = null;
  391.                     }
  392.                     // 累积总的窃取任务数
  393.                     stealCount += ns;
  394.                 }
  395.             }
  396.             // 读取工作队列 phase 值
  397.             phase = w.phase;
  398.         }
  399.         // 工作队列不是静止状态
  400.         if (phase != QUIET) {                         // else pre-adjusted
  401.             long c;                                   // decrement counts
  402.             // 活跃工作者线程数和总工作者线程数递减 1
  403.             do {} while (!CTL.weakCompareAndSet
  404.                     (this, c = ctl, RC_MASK & c - RC_UNIT |
  405.                     TC_MASK & c - TC_UNIT |
  406.                     SP_MASK & c));
  407.         }
  408.         // 如果工作者线程驻留的工作队列不为 null
  409.         if (w != null)
  410.         {
  411.             // 取消所有的任务
  412.             w.cancelAll();                            // cancel remaining tasks
  413.         }
  414.         /**
  415.          * 终止线程池失败 && 工作队列不为 null && 任务数组不为 null
  416.          */
  417.         if (!tryTerminate(false, false) &&            // possibly replace worker
  418.                 w != null && w.array != null) {
  419.             // 尝试创建或唤醒一个工作者线程
  420.             signalWork();
  421.         }
  422.         // 1）如果不是异常终止，则删除过时的异常信息
  423.         if (ex == null) {
  424.             ForkJoinTask.helpExpungeStaleExceptions();
  425.         } else {
  426.             // 2）重新抛出异常
  427.             ForkJoinTask.rethrow(ex);
  428.         }
  429.     }
  431.      * @param now
  432.      *  true 表示无条件终止，
  433.      *  false 表示等到线程池无任务或无活跃工作者线程之后终止
  434.      * @param enable true 可能在下次终止
  435.      * @return true if terminating or terminated
  436.      */
  437.     private boolean tryTerminate(boolean now, boolean enable) {
  438.         int md; // 3 phases: try to set SHUTDOWN, then STOP, then TERMINATED
  440.         // 线程池状态不是 SHUTDOWN
  441.         while (((md = mode) & SHUTDOWN) == 0) {
  442.             /**
  443.              *  enable 为 false 和通用线程池不允许终止
  444.              */
  445.             if (!enable || this == common) {
  446.                 return false;
  447.             } else {
  448.                 // 设置线程池状态为 SHUTDOWN
  449.                 MODE.compareAndSet(this, md, md | SHUTDOWN);
  450.             }
  451.         }
  453.         while (((md = mode) & STOP) == 0) {       // try to initiate termination
  454.             // 如果不是立刻终止
  455.             if (!now) {                           // check if quiescent & empty
  456.                 for (long oldSum = 0L;;) {        // repeat until stable
  457.                     boolean running = false;
  458.                     long checkSum = ctl;
  459.                     final WorkQueue[] ws = workQueues;
  460.                     // 1）有活跃的工作者线程
  461.                     if ((md & SMASK) + (int)(checkSum >> RC_SHIFT) > 0) {
  462.                         running = true;
  463.                         // 2）工作队列不为 null
  464.                     } else if (ws != null) {
  465.                         WorkQueue w; int b;
  466.                         // 遍历所有的工作队列，看是否有未完成的任务
  467.                         for (int i = 0; i < ws.length; ++i) {
  468.                             if ((w = ws[i]) != null) {
  469.                                 checkSum += (b = w.base) + w.id;
  470.                                 if (b != w.top ||
  471.                                         (i & 1) == 1 && w.source >= 0) {
  472.                                     // 工作队列中有任务未完成
  473.                                     running = true;
  474.                                     break;
  475.                                 }
  476.                             }
  477.                         }
  478.                     }
  479.                     // 1）线程池已经停止，则直接退出
  480.                     if (((md = mode) & STOP) != 0) {
  481.                         break;                 // already triggered
  482.                         // 2）有活跃工作者线程或有任务未完成，则返回 false
  483.                     } else if (running) {
  484.                         return false;
  485.                     } else if (workQueues == ws && oldSum == (oldSum = checkSum)) {
  486.                         break;
  487.                     }
  488.                 }
  489.             }
  490.             // 设置线程池状态为 STOP
  491.             if ((md & STOP) == 0) {
  492.                 MODE.compareAndSet(this, md, md | STOP);
  493.             }
  494.         }
  496.         // 线程池状态不是 TERMINATED
  497.         while (((md = mode) & TERMINATED) == 0) { // help terminate others
  498.             for (long oldSum = 0L;;) {            // repeat until stable
  499.                 WorkQueue[] ws; WorkQueue w;
  500.                 long checkSum = ctl;
  501.                 // workQueues 不为空
  502.                 if ((ws = workQueues) != null) {
  503.                     for (final WorkQueue element : ws) {
  504.                         // 当前任务队列不为 null
  505.                         if ((w = element) != null) {
  506.                             final ForkJoinWorkerThread wt = w.owner;
  507.                             // 取消所有的任务
  508.                             w.cancelAll();        // clear queues
  509.                             // 如果是工作队列
  510.                             if (wt != null) {
  511.                                 try {             // unblock join or park
  512.                                     // 中断工作者线程
  513.                                     wt.interrupt();
  514.                                 } catch (final Throwable ignore) {
  515.                                 }
  516.                             }
  517.                             // 累加校验和
  518.                             checkSum += w.base + w.id;
  519.                         }
  520.                     }
  521.                 }
  522.                 if (((md = mode) & TERMINATED) != 0 ||
  523.                         workQueues == ws && oldSum == (oldSum = checkSum)) {
  524.                     break;
  525.                 }
  526.             }
  527.             // 1）线程池已经终止
  528.             if ((md & TERMINATED) != 0) {
  529.                 break;
  530.                 // 2）还有工作者线程未中断
  531.             } else if ((md & SMASK) + (short)(ctl >>> TC_SHIFT) > 0) {
  532.                 break;
  533.                 // 3）设置线程池状态为 TERMINATED
  534.             } else if (MODE.compareAndSet(this, md, md | TERMINATED)) {
  535.                 synchronized (this) {
  536.                     notifyAll();                  // for awaitTermination
  537.                 }
  538.                 break;
  539.             }
  540.         }
  541.         // 终止成功返回 true
  542.         return true;
  543.     }
  545. WorkQueue#
  547.         /**
  548.          *  工作者线程将任务提交到自己驻留的工作队列中
  549.          */
  550.         void push(ForkJoinTask<?> task) {
  551.             // 读取 top 索引
  552.             final int s = top; ForkJoinTask<?>[] a; int al, d;
  553.             /**
  554.              * 1）保存任务的 ForkJoinTask 数组不为 null && 长度 > 0
  555.              */
  556.             if ((a = array) != null && (al = a.length) > 0) {
  557.                 // 基于旧的 top 索引计算任务存放的索引
  558.                 final int index = al - 1 & s;
  559.                 final ForkJoinPool p = pool;
  560.                 // 递增 top 索引
  561.                 top = s + 1;
  562.                 // 将任务存储到 ForkJoinTask 数组中
  563.                 QA.setRelease(a, index, task);
  564.                 // 1）如果是工作队列的第一个任务 && pool 不为 null
  565.                 if ((d = base - s) == 0 && p != null) {
  566.                     VarHandle.fullFence();
  567.                     // 尝试新增或唤醒工作者线程
  568.                     p.signalWork();
  569.                 }
  570.                 // 2）如果任务队列已满，则执行扩容
  571.                 else if (d + al == 1) {
  572.                     growArray();
  573.                 }
  574.             }
  575.         }

工作者线程的执行逻辑

  1. public class ForkJoinWorkerThread extends Thread {
  2.     // 工作者线程所属的线程池
  3.     final ForkJoinPool pool;
  4.     // 工作者驻留的任务队列
  5.     final ForkJoinPool.WorkQueue workQueue; 
  7.     /**
  8.      *  创建一个在目标 pool 中执行任务的 ForkJoinWorkerThread 实例
  9.      */
  10.     protected ForkJoinWorkerThread(ForkJoinPool pool) {
  11.         super("aForkJoinWorkerThread");
  12.         this.pool = pool;
  13.         // 将当前工作者线程注册到线程池中
  14.         this.workQueue = pool.registerWorker(this);
  15.     }
  17.     /**
  18.      *  工作线程启动前的钩子函数
  19.      */
  20.     protected void onStart() {
  21.     }
  23.     /**
  24.      *  工作者线程退出后的钩子函数
  25.      */
  26.     protected void onTermination(Throwable exception) {
  27.     }
  29.     /**
  30.      *  运行工作者线程
  31.      */
  32.     public void run() {
  33.         if (workQueue.array == null) { // only run once
  34.             Throwable exception = null;
  35.             try {
  36.                 // 前置钩子
  37.                 onStart();
  38.                 // 运行工作队列
  39.                 pool.runWorker(workQueue);
  40.             } catch (Throwable ex) {
  41.                 exception = ex;
  42.             } finally {
  43.                 try {
  44.                     // 后置钩子
  45.                     onTermination(exception);
  46.                 } catch (Throwable ex) {
  47.                     if (exception == null)
  48.                         exception = ex;
  49.                 } finally {
  50.                     // 注销工作者
  51.                     pool.deregisterWorker(this, exception);
  52.                 }
  53.             }
  54.         }
  55.     }
  57.     /**
  58.      *  工作者线程执行完驻留队列的任务后，会触发一次 afterTopLevelExec 回调
  59.      */
  60.     void afterTopLevelExec() {
  61.     }
  62. }
  63. ForkJoinPool#
  64.     /**
  65.      *  工作者线程的核心运行逻辑
  66.      */
  67.     final void runWorker(WorkQueue w) {
  68.         WorkQueue[] ws;
  69.         // 执行任务数组的初始化
  70.         w.growArray();                                  // allocate queue
  71.         // 计算随机窃取任务的任务队列索引
  72.         int r = w.id ^ ThreadLocalRandom.nextSecondarySeed();
  73.         if (r == 0) {
  74.             r = 1;
  75.         }
  76.         int lastSignalId = 0;                           // avoid unneeded signals
  77.         // 循环处理
  78.         while ((ws = workQueues) != null) {
  79.             boolean nonempty = false;                   // scan
  80.             /**
  81.              * n：length
  82.              * m：mask
  83.              * b：base
  84.              * i：index
  85.              * a：array
  86.              * q：WorkQueue
  87.              * al：array length
  88.              */
  89.             for (int n = ws.length, j = n, m = n - 1; j > 0; --j) {
  90.                 WorkQueue q; int i, b, al; ForkJoinTask<?>[] a;
  91.                 /**
  92.                  * 1）基于随机索引定位的任务队列不为 null &&
  93.                  * 目标任务队列中有任务需要处理 &&
  94.                  * 目标任务队列的任务数组不为空
  95.                  */
  96.                 if ((i = r & m) >= 0 && i < n &&        // always true
  97.                         (q = ws[i]) != null && (b = q.base) - q.top < 0 &&
  98.                         (a = q.array) != null && (al = a.length) > 0) {
  99.                     // 被窃取任务队列的 ID
  100.                     final int qid = q.id;                     // (never zero)
  101.                     // 计算任务索引，窃取任务是从 base 开始的
  102.                     final int index = al - 1 & b;
  103.                     // 读取目标任务
  104.                     final ForkJoinTask<?> t = (ForkJoinTask<?>)
  105.                             QA.getAcquire(a, index);
  106.                     // 任务被当前线程获取，未出现竞争
  107.                     if (t != null && b++ == q.base &&
  108.                             QA.compareAndSet(a, index, t, null)) {
  109.                         /**
  110.                          * 当前任务队列里还有任务待处理 &&
  111.                          * 第一次窃取该任务队列里的任务
  112.                          */
  113.                         if ((q.base = b) - q.top < 0 && qid != lastSignalId)
  114.                         {
  115.                             // 尝试增加或唤醒一个工作者线程来帮忙处理任务
  116.                             signalWork();               // propagate signal
  117.                         }
  118.                         // 写入上一次窃取的任务队列 ID
  119.                         w.source = lastSignalId = qid;
  120.                         // 执行目标任务
  121.                         t.doExec();
  122.                         // 1）当前工作队列如果是 FIFO 模式
  123.                         if ((w.id & FIFO) != 0) {
  124.                             // 则从 base 位置开始处理自己的任务
  125.                             w.localPollAndExec(POLL_LIMIT);
  126.                         } else {
  127.                             // 则从 top 位置开始处理自己的任务
  128.                             w.localPopAndExec(POLL_LIMIT);
  129.                         }
  130.                         // 读取工作队列驻留线程
  131.                         final ForkJoinWorkerThread thread = w.owner;
  132.                         // 递增窃取任务数
  133.                         ++w.nsteals;
  134.                         // 重置窃取任务队列 ID
  135.                         w.source = 0;                   // now idle
  136.                         if (thread != null) {
  137.                             // 驻留线程不为 null，则执行 afterTopLevelExec 回调
  138.                             thread.afterTopLevelExec();
  139.                         }
  140.                     }
  141.                     // 处理完一个任务之后，再次尝试窃取该任务队列里的任务
  142.                     nonempty = true;
  143.                 }
  144.                 // 2）如果目标任务队列里的任务已经处理完毕，则退出此次扫描【一次只处理一个任务队列】
  145.                 else if (nonempty) {
  146.                     break;
  147.                 // 3）定位到的任务队列无任务可处理，则扫描下一个任务队列
  148.                 } else {
  149.                     ++r;
  150.                 }
  151.             }
  153.             // 1）如果成功处理完一个任务队列里的任务，则重新进行定位
  154.             if (nonempty) {                             // move (xorshift)
  155.                 r ^= r << 13; r ^= r >>> 17; r ^= r << 5;
  156.             }
  157.             // 2）扫描了所有的任务队列都没有任务可处理
  158.             else {
  159.                 int phase;
  160.                 // 重置 lastSignalId
  161.                 lastSignalId = 0;                       // clear for next scan
  162.                 // 1）如果队列还未进入静止状态
  163.                 if ((phase = w.phase) >= 0) {           // enqueue
  164.                     // 写入队列 ID 及其工作队列索引
  165.                     final int np = w.phase = phase + SS_SEQ | UNSIGNALLED;
  166.                     long c, nc;
  167.                     do {
  168.                         // 记录先前的控制变量到 stackPred 中
  169.                         w.stackPred = (int)(c = ctl);
  170.                         // 活跃工作者数递减 1，同时写入 np
  171.                         nc = c - RC_UNIT & UC_MASK | SP_MASK & np;
  172.                     // 将当前队列的状态写入控制变量中，写入成功后尝试执行最后一次扫描
  173.                     } while (!CTL.weakCompareAndSet(this, c, nc));
  174.                 }
  175.                 else {                                  // already queued
  176.                     // 读取 stackPred
  177.                     final int pred = w.stackPred;
  178.                     // 工作队列置为静止 && 需要唤醒信号
  179.                     w.source = DORMANT;                 // enable signal
  180.                     for (int steps = 0;;) {
  181.                         int md, rc; long c;
  182.                         if (w.phase >= 0) {
  183.                             w.source = 0;
  184.                             break;
  185.                         }
  186.                         // 2）线程池正在停止，则当前工作者需要退出
  187.                         else if ((md = mode) < 0) {
  188.                             return;
  189.                         // 3）线程池正在关闭，则当前工作者需要退出
  190.                         } else if ((rc = (md & SMASK) +  // possibly quiescent
  191.                                 (int)((c = ctl) >> RC_SHIFT)) <= 0 &&
  192.                                 (md & SHUTDOWN) != 0 &&
  193.                                 tryTerminate(false, false)) {
  194.                             return;                     // help terminate
  195.                         // 4）在多次阻塞之间清空中断状态
  196.                         } else if ((++steps & 1) == 0) {
  197.                             Thread.interrupted();       // clear between parks
  198.                         /**
  199.                          * 5）当前已经无活跃工作者线程 &&
  200.                          * 已经有工作队列静止 &&
  201.                          * 当前队列是最近静止的工作队列
  202.                          */
  203.                         } else if (rc <= 0 && pred != 0 && phase == (int)c) {
  204.                             // 计算截止时间
  205.                             final long d = keepAlive + System.currentTimeMillis();
  206.                             // 阻塞到截止时间
  207.                             LockSupport.parkUntil(this, d);
  208.                             // 阻塞过程中一直无任务提交
  209.                             if (ctl == c &&
  210.                                     d - System.currentTimeMillis() <= TIMEOUT_SLOP) {
  211.                                 // 递减总工作者线程数
  212.                                 final long nc = UC_MASK & c - TC_UNIT |
  213.                                         SP_MASK & pred;
  214.                                 // 更新控制变量
  215.                                 if (CTL.compareAndSet(this, c, nc)) {
  216.                                     // 将工作队列设置为静止状态
  217.                                     w.phase = QUIET;
  218.                                     // 当前工作者退出工作
  219.                                     return;             // drop on timeout
  220.                                 }
  221.                             }
  222.                         // 6）阻塞当前工作者等待唤醒，ForkJoinPool 保证至少会有一个工作者线程不会退出
  223.                         } else {
  224.                             LockSupport.park(this);
  225.                         }
  226.                     }
  227.                 }
  228.             }
  229.         }
  230.     }
  232.     /**
  233.      *  将工作者线程 wt 注册到当前线程池中
  234.      */
  235.     final WorkQueue registerWorker(ForkJoinWorkerThread wt) {
  236.         UncaughtExceptionHandler handler;
  237.         // 设置为守护线程
  238.         wt.setDaemon(true);
  239.         // 如果存在异常处理器
  240.         if ((handler = ueh) != null) {
  241.             // 写入异常处理器
  242.             wt.setUncaughtExceptionHandler(handler);
  243.         }
  244.         // 为工作者线程创建一个工作队列
  245.         final WorkQueue w = new WorkQueue(this, wt);
  246.         int tid = 0;                                    // for thread name
  247.         // 线程池是否为 FIFO 模式
  248.         final int fifo = mode & FIFO;
  249.         // 读取工作者线程名称前缀
  250.         final String prefix = workerNamePrefix;
  251.         if (prefix != null) {
  252.             synchronized (prefix) {
  253.                 final WorkQueue[] ws = workQueues; int n;
  254.                 // 计算索引种子
  255.                 final int s = indexSeed += SEED_INCREMENT;
  256.                 if (ws != null && (n = ws.length) > 1) {
  257.                     // 计算掩码
  258.                     final int m = n - 1;
  259.                     // 基于索引种子、掩码计算队列 ID
  260.                     tid = s & m;
  261.                     // 计算奇数索引值
  262.                     int i = m & (s << 1 | 1);         // odd-numbered indices
  263.                     // 查找空闲的 slot
  264.                     for (int probes = n >>> 1;;) {      // find empty slot
  265.                         WorkQueue q;
  266.                         // 1）当前索引定位的任务队列为 null || 任务队列为静止状态
  267.                         if ((q = ws[i]) == null || q.phase == QUIET) {
  268.                             break;
  269.                         // 2）所有的奇数索引位都已被占用，则需要进行扩容
  270.                         } else if (--probes == 0) {
  271.                             i = n | 1;                  // resize below
  272.                             break;
  273.                         // 3）计算下一个奇数索引位
  274.                         } else {
  275.                             i = i + 2 & m;
  276.                         }
  277.                     }
  279.                     // 写入工作队列索引、模式等
  280.                     final int id = i | fifo | s & ~(SMASK | FIFO | DORMANT);
  281.                     // 写入队列 ID
  282.                     w.phase = w.id = id;                // now publishable
  283.                     // 如果索引 i 所在的 slot 为空或工作队列为静止状态
  284.                     if (i < n) {
  285.                         // 写入工作队列
  286.                         ws[i] = w;
  287.                     } else {                              // expand array
  288.                         // 执行 WorkQueue 的扩容
  289.                         final int an = n << 1;
  290.                         // 双倍扩容
  291.                         final WorkQueue[] as = new WorkQueue[an];
  292.                         // 写入工作队列
  293.                         as[i] = w;
  294.                         final int am = an - 1;
  295.                         for (int j = 0; j < n; ++j) {
  296.                             WorkQueue v;                // copy external queue
  297.                             // 迁移旧 workQueues 中的任务队列
  298.                             if ((v = ws[j]) != null) {
  299.                                 as[v.id & am & SQMASK] = v;
  300.                             }
  301.                             if (++j >= n) {
  302.                                 break;
  303.                             }
  304.                             as[j] = ws[j];              // copy worker
  305.                         }
  306.                         // 写入 workQueues
  307.                         workQueues = as;
  308.                     }
  309.                 }
  310.             }
  311.             // 设置工作者线程名称
  312.             wt.setName(prefix.concat(Integer.toString(tid)));
  313.         }
  314.         return w;
  315.     }

ForkJoinTask.fork/join/invoke

  • fork：将任务提交到 ForkJoinPool 中异步执行
  1.     /**
  2.      *  1）如果当前线程是 ForkJoinPool 工作者线程，则将其提交到驻留的工作队列中。
  3.      *  2）否则将当前 ForkJoinTask 任务提交到 common 池中
  4.      */
  5.     public final ForkJoinTask<V> fork() {
  6.         Thread t;
  7.         if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) {
  8.             ((ForkJoinWorkerThread)t).workQueue.push(this);
  9.         } else {
  10.             ForkJoinPool.common.externalPush(this);
  11.         }
  12.         return this;
  13.     }
  • join
  1.     /**
  2.      *  阻塞等待当前 ForkJoinTask 执行完成并返回结果，
  3.      *  任务执行过程中可以抛出 RuntimeException 或 Error 异常。
  4.      *  任务执行线程可以是当前线程或其他工作者线程。
  5.      */
  6.     public final V join() {
  7.         int s;
  8.         // 1）阻塞等待任务执行完成，如果是异常完成，则将抛出 RuntimeException 或 Error。
  9.         if (((s = doJoin()) & ABNORMAL) != 0) {
  10.             reportException(s);
  11.         }
  12.         // 2）执行成功则返回原始结果
  13.         return getRawResult();
  14.     }
  16.     private int doJoin() {
  17.         int s; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;
  18.         /**
  19.          * 1）如果任务已经完成，则返回其状态
  20.          * 2）如果当前线程是 ForkJoinWorkerThread &&
  21.          *  则尝试从驻留工作队列顶部拉取此任务 &&
  22.          *  在当前线程中执行此任务 &&
  23.          *  执行成功则返回任务状态
  24.          * 3）如果当前线程是 ForkJoinWorkerThread，但是拉取任务失败，
  25.          *  则表示【目标任务不在顶部、或其他的工作者线程窃取了此任务在执行】，则等待任务完成。
  26.          * 4）如果当前线程不是 ForkJoinWorkerThread，则阻塞等待任务完成。
  27.          */
  28.         return (s = status) < 0 ? s :
  29.             (t = Thread.currentThread()) instanceof ForkJoinWorkerThread ?
  30.                     (w = (wt = (ForkJoinWorkerThread)t).workQueue).
  31.                     tryUnpush(this) && (s = doExec()) < 0 ? s :
  32.                         wt.pool.awaitJoin(w, this, 0L) :
  33.                             externalAwaitDone();
  34.     }
  36. ForkJoinPool#WorkQueue#
  37.         /**
  38.          *  只有当目标任务 task 是工作队列顶部的第一个任务时，才将此任务移除，并返回 true，
  39.          *  否则返回 false。
  40.          */
  41.         boolean tryUnpush(ForkJoinTask<?> task) {
  42.             // 读取 base
  43.             final int b = base;
  44.             // 读取 top
  45.             int s = top, al; ForkJoinTask<?>[] a;
  46.             // 任务数组不为空 && 有任务待处理
  47.             if ((a = array) != null && b != s && (al = a.length) > 0) {
  48.                 // 计算读取索引
  49.                 final int index = al - 1 & --s;
  50.                 // 如果顶部任务就是当前任务 task，则将 slot 置为 null
  51.                 if (QA.compareAndSet(a, index, task, null)) {
  52.                     // 更新 top 值，并返回 true
  53.                     top = s;
  54.                     VarHandle.releaseFence();
  55.                     return true;
  56.                 }
  57.             }
  58.             return false;
  59.         }
  61.     /**
  62.      *  窃取任务的主要执行方法
  63.      */
  64.     final int doExec() {
  65.         int s; boolean completed;
  66.         // 任务未完成
  67.         if ((s = status) >= 0) {
  68.             try {
  69.                 // 立即执行任务
  70.                 completed = exec();
  71.             } catch (final Throwable rex) {
  72.                 completed = false;
  73.                 // 设置异常状态
  74.                 s = setExceptionalCompletion(rex);
  75.             }
  76.             // 如果正常完成
  77.             if (completed) {
  78.                 // 设置完成状态
  79.                 s = setDone();
  80.             }
  81.         }
  82.         return s;
  83.     }
  85.     /**
  86.      *  记录异常信息，触发 internalPropagateException 钩子函数
  87.      */
  88.     private int setExceptionalCompletion(Throwable ex) {
  89.         final int s = recordExceptionalCompletion(ex);
  90.         if ((s & THROWN) != 0) {
  91.             internalPropagateException(ex);
  92.         }
  93.         return s;
  94.     }
  96.     final int recordExceptionalCompletion(Throwable ex) {
  97.         int s;
  98.         // 任务未完成
  99.         if ((s = status) >= 0) {
  100.             // 计算此 ForkJoinTask 的哈希值
  101.             final int h = System.identityHashCode(this);
  102.             // 读取异常表的锁
  103.             final ReentrantLock lock = exceptionTableLock;
  104.             lock.lock();
  105.             try {
  106.                 expungeStaleExceptions();
  107.                 // 读取异常表
  108.                 final ExceptionNode[] t = exceptionTable;
  109.                 // 计算索引
  110.                 final int i = h & t.length - 1;
  111.                 // 遍历单向链表
  112.                 for (ExceptionNode e = t[i]; ; e = e.next) {
  113.                     /**
  114.                      * 1）目标 slot 为 null
  115.                      * 2）已经到达链表尾部
  116.                      */
  117.                     if (e == null) {
  118.                         // 则将此异常加入异常表
  119.                         t[i] = new ExceptionNode(this, ex, t[i],
  120.                                 exceptionTableRefQueue);
  121.                         break;
  122.                     }
  123.                     // 如果已经加入了，则直接退出
  124.                     if (e.get() == this) {
  125.                         break;
  126.                     }
  127.                 }
  128.             } finally {
  129.                 lock.unlock();
  130.             }
  131.             // 设置任务状态
  132.             s = abnormalCompletion(DONE | ABNORMAL | THROWN);
  133.         }
  134.         return s;
  135.     }
  137.     /**
  138.      *  尝试将当前 ForkJoinTask 标记为由于取消或异常而完成
  139.      */
  140.     private int abnormalCompletion(int completion) {
  141.         for (int s, ns;;) {
  142.             // 任务已经完成，则返回
  143.             if ((s = status) < 0) {
  144.                 return s;
  145.                 // 更新任务状态
  146.             } else if (STATUS.weakCompareAndSet(this, s, ns = s | completion)) {
  147.                 // 如果有线程阻塞依赖该任务完成，则唤醒所有的阻塞线程
  148.                 if ((s & SIGNAL) != 0) {
  149.                     synchronized (this) { notifyAll(); }
  150.                 }
  151.                 return ns;
  152.             }
  153.         }
  154.     }
  156.     /**
  157.      *  将任务状态设置为 DONE，如果有其他线程在阻塞等待该任务完成，则唤醒所有阻塞的线程
  158.      */
  159.     private int setDone() {
  160.         int s;
  161.         /**
  162.          *  1）将任务状态设置为 DONE
  163.          *  2）如果有其他线程在阻塞等待该任务完成，则唤醒所有阻塞的线程
  164.          */
  165.         if (((s = (int)STATUS.getAndBitwiseOr(this, DONE)) & SIGNAL) != 0) {
  166.             synchronized (this) { notifyAll(); }
  167.         }
  168.         return s | DONE;
  169.     }
  171. ForkJoinPool#WorkQueue#
  172.         /**
  173.          *  从工作队列的 top 位置开始循环扫描目标任务 task，如果找到则将其移除并执行
  174.          */
  175.         void tryRemoveAndExec(ForkJoinTask<?> task) {
  176.             ForkJoinTask<?>[] wa; int s, wal;
  177.             // 此工作队列中有任务待处理
  178.             if (base - (s = top) < 0 && // traverse from top
  179.                     (wa = array) != null && (wal = wa.length) > 0) {
  180.                 // 从工作队列的 top 位置开始循环扫描目标任务 task，如果找到则将其移除并执行
  181.                 for (int m = wal - 1, ns = s - 1, i = ns; ; --i) {
  182.                     final int index = i & m;
  183.                     final ForkJoinTask<?> t = (ForkJoinTask<?>)
  184.                             QA.get(wa, index);
  185.                     // 1）已经没有更多的任务待扫描
  186.                     if (t == null) {
  187.                         break;
  188.                     // 2）当前任务就是目标任务 task
  189.                     } else if (t == task) {
  190.                         // 移除该任务
  191.                         if (QA.compareAndSet(wa, index, t, null)) {
  192.                             top = ns;   // 将已扫描的任务集体下移一个位置
  193.                             for (int j = i; j != ns; ++j) {
  194.                                 ForkJoinTask<?> f;
  195.                                 final int pindex = j + 1 & m;
  196.                                 f = (ForkJoinTask<?>)QA.get(wa, pindex);
  197.                                 QA.setVolatile(wa, pindex, null);
  198.                                 final int jindex = j & m;
  199.                                 QA.setRelease(wa, jindex, f);
  200.                             }
  201.                             VarHandle.releaseFence();
  202.                             // 执行目标任务
  203.                             t.doExec();
  204.                         }
  205.                         break;
  206.                     }
  207.                 }
  208.             }
  209.         }
  211.     final int awaitJoin(WorkQueue w, ForkJoinTask<?> task, long deadline) {
  212.         int s = 0;
  213.         /**
  214.          *  工作队列不为 null && 任务不为 null
  215.          *  1）task 不是 CountedCompleter 任务
  216.          *  2）task 是 CountedCompleter，则尝试窃取和执行目标计算中的任务，直到其完成或无法找到任务为止
  217.          */
  218.         if (w != null && task != null &&
  219.                 (!(task instanceof CountedCompleter) ||
  220.                         (s = w.localHelpCC((CountedCompleter<?>)task, 0)) >= 0)) {
  221.             // 尝试从工作队列中移除并运行此任务
  222.             w.tryRemoveAndExec(task);
  223.             // 读取上次窃取的任务队列ID和当前队列的ID
  224.             final int src = w.source, id = w.id;
  225.             // 读取任务状态
  226.             s = task.status;
  227.             // 任务未完成
  228.             while (s >= 0) {
  229.                 WorkQueue[] ws;
  230.                 boolean nonempty = false;
  231.                 // 获取随机奇数索引
  232.                 final int r = ThreadLocalRandom.nextSecondarySeed() | 1; // odd indices
  233.                 if ((ws = workQueues) != null) {       // scan for matching id
  234.                     for (int n = ws.length, m = n - 1, j = -n; j < n; j += 2) {
  235.                         WorkQueue q; int i, b, al; ForkJoinTask<?>[] a;
  236.                         /**
  237.                          *  目标索引 i 定位到的工作队列不为 null   &&
  238.                          *  此工作队列最近窃取了当前工作队列的任务 &&
  239.                          *  此工作队列有任务待处理 &&
  240.                          *  则帮助其处理任务
  241.                          */
  242.                         if ((i = r + j & m) >= 0 && i < n &&
  243.                                 (q = ws[i]) != null && q.source == id &&
  244.                                 (b = q.base) - q.top < 0 &&
  245.                                 (a = q.array) != null && (al = a.length) > 0) {
  246.                             // 窃取任务的队列ID
  247.                             final int qid = q.id;
  248.                             // 从 base 位置开始窃取
  249.                             final int index = al - 1 & b;
  250.                             // 读取任务
  251.                             final ForkJoinTask<?> t = (ForkJoinTask<?>)
  252.                                     QA.getAcquire(a, index);
  253.                             /**
  254.                              *  目标任务不为 null &&
  255.                              *  没有其他队列并发窃取此任务 &&
  256.                              *  则尝试将此任务从目标工作队列中移除
  257.                              */
  258.                             if (t != null && b++ == q.base && id == q.source &&
  259.                                     QA.compareAndSet(a, index, t, null)) {
  260.                                 // 窃取成功，则更新 base 值
  261.                                 q.base = b;
  262.                                 // 记录最近窃取任务的任务队列 ID
  263.                                 w.source = qid;
  264.                                 // 执行目标任务
  265.                                 t.doExec();
  266.                                 // 回写上次窃取任务的队列ID
  267.                                 w.source = src;
  268.                             }
  269.                             nonempty = true;
  270.                             // 窃取并处理完一个任务，则退出循环
  271.                             break;
  272.                         }
  273.                     }
  274.                 }
  275.                 // 1）目标任务已经完成，则返回
  276.                 if ((s = task.status) < 0) {
  277.                     break;
  278.                 // 2）一个任务都没有窃取到
  279.                 } else if (!nonempty) {
  280.                     long ms, ns; int block;
  281.                     // 1）非超时模式
  282.                     if (deadline == 0L) {
  283.                         ms = 0L;                       // untimed
  284.                     // 2）如果已经超时，则返回
  285.                     } else if ((ns = deadline - System.nanoTime()) <= 0L) {
  286.                         break;                         // timeout
  287.                     // 3）未超时，但是剩余时间 < 1 毫秒，则将其设置为 1 毫秒
  288.                     } else if ((ms = TimeUnit.NANOSECONDS.toMillis(ns)) <= 0L)
  289.                     {
  290.                         ms = 1L;                       // avoid 0 for timed wait
  291.                     }
  292.                     // 尝试增加一个补偿工作者来处理任务
  293.                     if ((block = tryCompensate(w)) != 0) {
  294.                         // 阻塞等待
  295.                         task.internalWait(ms);
  296.                         // 如果添加成功，则递增活跃工作者数
  297.                         CTL.getAndAdd(this, block > 0 ? RC_UNIT : 0L);
  298.                     }
  299.                     s = task.status;
  300.                 }
  301.             }
  302.         }
  303.         return s;
  304.     }
  306.     /**
  307.      *  如果任务未完成，则阻塞等待
  308.      */
  309.     final void internalWait(long timeout) {
  310.         /**
  311.          * 将(旧 status 值 | SIGNAL) 的值写入 status 中，并返回旧值
  312.          * 如果任务未完成
  313.          */
  314.         if ((int)STATUS.getAndBitwiseOr(this, SIGNAL) >= 0) {
  315.             synchronized (this) {
  316.                 // 1）如果任务未完成，则阻塞等待
  317.                 if (status >= 0) {
  318.                     try { wait(timeout); } catch (final InterruptedException ie) { }
  319.                 // 2）如果任务已经完成，则唤醒阻塞在此任务上的所有线程
  320.                 } else {
  321.                     notifyAll();
  322.                 }
  323.             }
  324.         }
  325.     }
  327.     /**
  328.      *  阻塞一个非工作者线程，直到任务完成
  329.      */
  330.     private int externalAwaitDone() {
  331.         int s = tryExternalHelp();
  332.         // 任务未完成 && 写入唤醒标记
  333.         if (s >= 0 && (s = (int)STATUS.getAndBitwiseOr(this, SIGNAL)) >= 0) {
  334.             boolean interrupted = false;
  335.             synchronized (this) {
  336.                 for (;;) {
  337.                     // 1）任务未完成
  338.                     if ((s = status) >= 0) {
  339.                         try {
  340.                             // 阻塞等待任务完成
  341.                             wait(0L);
  342.                         // 工作者线程被中断，可能是线程池终止
  343.                         } catch (final InterruptedException ie) {
  344.                             interrupted = true;
  345.                         }
  346.                     }
  347.                     // 2）任务完成则唤醒在此任务上阻塞等待的线程
  348.                     else {
  349.                         notifyAll();
  350.                         break;
  351.                     }
  352.                 }
  353.             }
  354.             // 工作者线程被设置了中断标记
  355.             if (interrupted) {
  356.                 // 则中断此工作者线程
  357.                 Thread.currentThread().interrupt();
  358.             }
  359.         }
  360.         // 返回任务状态
  361.         return s;
  362.     }
  364.     private int tryExternalHelp() {
  365.         int s;
  366.         /**
  367.          * 1）当前任务已经完成，则返回其状态
  368.          * 2）任务未完成，此任务是 CountedCompleter，则执行 externalHelpComplete
  369.          * 3）任务未完成，此任务是 ForkJoinTask，则执行 tryExternalUnpush && 拉取任务成功，则执行它
  370.          */
  371.         return (s = status) < 0 ? s:
  372.             this instanceof CountedCompleter ?
  373.                     ForkJoinPool.common.externalHelpComplete(
  374.                             (CountedCompleter<?>)this, 0) :
  375.                                 ForkJoinPool.common.tryExternalUnpush(this) ?
  376.                                         doExec() : 0;
  377.     }
  379.     final boolean tryExternalUnpush(ForkJoinTask<?> task) {
  380.         // 读取线程测试值
  381.         final int r = ThreadLocalRandom.getProbe();
  382.         WorkQueue[] ws; WorkQueue w; int n;
  383.         // 定位到的共享队列不为 null，则尝试从目标共享队列中移除此任务
  384.         return (ws = workQueues) != null &&
  385.                 (n = ws.length) > 0 &&
  386.                 (w = ws[n - 1 & r & SQMASK]) != null &&
  387.                 w.trySharedUnpush(task);
  388.     }
  390. ForkJoinPool#WorkQueue
  391.         boolean trySharedUnpush(ForkJoinTask<?> task) {
  392.             boolean popped = false;
  393.             final int s = top - 1;
  394.             int al; ForkJoinTask<?>[] a;
  395.             // 任务数组不为空
  396.             if ((a = array) != null && (al = a.length) > 0) {
  397.                 // 计算目标索引
  398.                 final int index = al - 1 & s;
  399.                 // 读取任务
  400.                 final ForkJoinTask<?> t = (ForkJoinTask<?>) QA.get(a, index);
  401.                 // 读取的任务就是目标任务 task && 尝试锁定共享队列
  402.                 if (t == task &&
  403.                         PHASE.compareAndSet(this, 0, QLOCK)) {
  404.                     // 锁定成功 && 确认没有出现竞争 && 将目标 slot 置为 null
  405.                     if (top == s + 1 && array == a &&
  406.                             QA.compareAndSet(a, index, task, null)) {
  407.                         // 成功弹出任务
  408.                         popped = true;
  409.                         // 更新 top 值
  410.                         top = s;
  411.                     }
  412.                     // 释放共享锁
  413.                     PHASE.setRelease(this, 0);
  414.                 }
  415.             }
  416.             return popped;
  417.         }
  • invoke
  1.     /**
  2.      *  立即在当前线程中执行此任务，等待任务执行完毕并返回结果，
  3.      *  或抛出 RuntimeException 或 Error 异常。
  4.      */
  5.     public final V invoke() {
  6.         int s;
  7.         if (((s = doInvoke()) & ABNORMAL) != 0) {
  8.             reportException(s);
  9.         }
  10.         return getRawResult();
  11.     }
  13.     private int doInvoke() {
  14.         int s; Thread t; ForkJoinWorkerThread wt;
  15.         return (s = doExec()) < 0 ? s :
  16.             (t = Thread.currentThread()) instanceof ForkJoinWorkerThread ?
  17.                     (wt = (ForkJoinWorkerThread)t).pool.
  18.                     awaitJoin(wt.workQueue, this, 0L) :
  19.                         externalAwaitDone();
  20.     }

ForkJoinPool 源码分析的更多相关文章

  1. ForkJoinPool源码简单解析

    ForkJoin框架之ForkJoinTask  java  阅读约 62 分钟 前言 在前面的文章"CompletableFuture和响应式编程"中提到了ForkJoinTas ...

  2. 多线程高并发编程(8) -- Fork/Join源码分析

    一.概念 Fork/Join就是将一个大任务分解(fork)成许多个独立的小任务,然后多线程并行去处理这些小任务,每个小任务处理完得到结果再进行合并(join)得到最终的结果. 流程:任务继承Recu ...

  3. 源码分析：Phaser 之更灵活的同步屏障

    简介 Phaser 是 JDK 1.7 开始提供的一个可重复使用的同步屏障,功能类似于CyclicBarrier和CountDownLatch,但使用更灵活,支持对任务的动态调整,并支持分层结构来达到 ...

  4. ABP源码分析一：整体项目结构及目录

    ABP是一套非常优秀的web应用程序架构,适合用来搭建集中式架构的web应用程序. 整个Abp的Infrastructure是以Abp这个package为核心模块(core)+15个模块(module ...

  5. HashMap与TreeMap源码分析

    1. 引言     在红黑树--算法导论(15)中学习了红黑树的原理.本来打算自己来试着实现一下,然而在看了JDK(1.8.0)TreeMap的源码后恍然发现原来它就是利用红黑树实现的(很惭愧学了Ja ...

  6. nginx源码分析之网络初始化

    nginx作为一个高性能的HTTP服务器,网络的处理是其核心,了解网络的初始化有助于加深对nginx网络处理的了解,本文主要通过nginx的源代码来分析其网络初始化. 从配置文件中读取初始化信息 与网 ...

  7. zookeeper源码分析之五服务端(集群leader)处理请求流程

    leader的实现类为LeaderZooKeeperServer,它间接继承自标准ZookeeperServer.它规定了请求到达leader时需要经历的路径: PrepRequestProcesso ...

  8. zookeeper源码分析之四服务端(单机)处理请求流程

    上文: zookeeper源码分析之一服务端启动过程 中,我们介绍了zookeeper服务器的启动过程,其中单机是ZookeeperServer启动,集群使用QuorumPeer启动,那么这次我们分析 ...

  9. zookeeper源码分析之三客户端发送请求流程

    znode 可以被监控,包括这个目录节点中存储的数据的修改,子节点目录的变化等,一旦变化可以通知设置监控的客户端,这个功能是zookeeper对于应用最重要的特性,通过这个特性可以实现的功能包括配置的 ...

随机推荐

  1. SpringDataJPA第三天讲义

    第1章     Specifications动态查询 有时我们在查询某个实体的时候,给定的条件是不固定的,这时就需要动态构建相应的查询语句,在Spring Data JPA中可以通过JpaSpecif ...

  2. Image Processing and Analysis_15_Image Registration： A Method for Registration of 3-D shapes——1992

    此主要讨论图像处理与分析.虽然计算机视觉部分的有些内容比如特 征提取等也可以归结到图像分析中来,但鉴于它们与计算机视觉的紧密联系,以 及它们的出处,没有把它们纳入到图像处理与分析中来.同样,这里面也有 ...

  3. json —— pickle 的序列化和反序列化

    前言json的序列化和反序列化 1, json 只能序列化简单的数据类型,如,列表,字典,字符串,等简单的类型,不能序列化复杂的类型. 2, json 是支持所有的语言的,多以我们跨语言的时候都是用j ...

  4. Codeforces Round #590 (Div. 3) 万恶的自己WAC

    C题:一道简单的C题卡了半天,我太菜了 题意:给你一个n*2的矩阵,每个位置有一个数字,对应一种管道,要求通道可不可以从左上通到右下 由提议可以看出,1,2对应的是直管道,3,4,5,6对应弯管道,只 ...

  5. LoadRunner生成测试报告

     loadrunner笔记(三):设置.运行场景和生成测试报告   //上一篇的代码有点问题,问题出在 web_reg_find()函数中,这个函数简单的说是搜索下一步操作的请求对象(html)页面中 ...

  6. javascript逻辑非（！/！！）

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  7. 牛客小白月赛11 Rinne Loves Xor

    题目链接:https://ac.nowcoder.com/acm/contest/370/I code: #include<bits/stdc++.h> using namespace s ...

  8. 外网可以反问lxr

    , 'baseurl_aliases' => 174       [ 'http://172.168.2.4/lxr' 175       , 'http://mydomain/lxr' 176 ...

  9. Day1 读题解题提升

    The 2014 ACM-ICPC Asia Mudanjiang Regional Contest 昨晚做了训练赛,然后读题又自闭了QAQ. Average Score ZOJ - 3819 题意: ...

  10. Density of Power Network（ZOJ 3708）

    Problem The vast power system is the most complicated man-made system and the greatest engineering i ...