public final V join() {

        // doJoin方法返回该任务的状态，状态值有三种：

        // NORMAL, CANCELLED和EXCEPTIONAL

        // join的等待过程在doJoin方法中进行

        if (doJoin() != NORMAL)

            // reportResult方法针对任务的三种状态有三种处理方式：

            // NORMAL: 直接返回getRawResult()方法的返回值

            // CANCELLED: 抛出CancellationException

            // EXCEPTIONAL: 如果任务执行过程抛出了异常，则抛出该异常，否则返回getRawResult()

            return reportResult();

        else

            // getRawResult是抽象方法，由子类来实现

            return getRawResult();

    }

    private int doJoin() {

        Thread t; ForkJoinWorkerThread w; int s; boolean completed;

        // 针对ForkJoinWorkerThread调用join的情况

        if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) {

            // status值的初始化值是0，在任务没有完成以前一直是非负值

            // 因此一旦status的值变成负数，表示任务已经完成，直接返回

            if ((s = status) < 0)

                return s;

            // 检查当前worker线程的任务栈（因为采用LIFO方式，所有这里称为栈）

            // 的栈顶的任务是不是当前任务，如果是，从栈中取走该任务并执行

            // 然后返回执行之后任务的状态

            if ((w = (ForkJoinWorkerThread)t).unpushTask(this)) {

                try {

                    completed = exec();

                } catch (Throwable rex) {

                    return setExceptionalCompletion(rex);

                }

                if (completed)

                    return setCompletion(NORMAL);

            }

            // 如果不是栈顶任务的情况

            return w.joinTask(this);

        }

        else

            // 外部线程等待任务结束的情况

            return externalAwaitDone();

    }

    final int joinTask(ForkJoinTask<?> joinMe) {

        ForkJoinTask<?> prevJoin = currentJoin;

        currentJoin = joinMe;

        for (int s, retries = MAX_HELP;;) {

            // 当前任务已经完成，返回到前面一个join的任务

            if ((s = joinMe.status) < 0) {

                currentJoin = prevJoin;

                return s;

            }

            // 剩余的尝试次数大于0（MAX_HELP值为16）的情况，继续做尝试

            if (retries > 0) {

                if (queueTop != queueBase) {

                    // 检查当前线程的任务栈，如果任务栈不为空，当前任务处在栈顶位置则

                    // 执行该任务返回true，否则返回false，直接认为尝试失败

                    if (!localHelpJoinTask(joinMe))

                        retries = 0;

                }

                // 尝试了最大允许次数的一半

                else if (retries == MAX_HELP >>> 1) {

                    --retries;

                    // 检查当前任务是否在某个worker线程的任务队列的队首位置

                    // 如果是的话，偷走这个任务并且执行掉该任务。tryDeqAndExec

                    // 返回任务的status值，因此大于等于0意味着任务还没有执行结束，

                    // 当前线程让出控制权以便其他线程执行任务

                    if (tryDeqAndExec(joinMe) >= 0)

                        Thread.yield();

                }

                else

                    // helpJoinTask方法检查当前任务是不是被某个Worker线程偷走了，

                    // 并且是这个线程最新偷走的任务（currentSteal），如果是的话，

                    // 当前线程帮助执行这个任务，这个过程成功则返回true

                    retries = helpJoinTask(joinMe) ? MAX_HELP : retries - 1;

            }

            else {

                // 尝试了最大允许次数还没有成功，重置以便再次尝试

                retries = MAX_HELP;

                // 一轮尝试失败，进入进程池等待任务

                pool.tryAwaitJoin(joinMe);

            }

        }

    }

    final void tryAwaitJoin(ForkJoinTask<?> joinMe) {

        int s;

        // 检查任务是否结束之前先清除当前线程的中断状态
        // 因为tryAwaitDone会调用wait可能产生中断异常

        Thread.interrupted();

        // 任务还在执行的情况，否则执行完成就直接返回

        if (joinMe.status >= 0) {

            // blockedCount加1，把当前线程标记为阻塞

            // 成功则返回true，否则返回false

            if (tryPreBlock()) {

                // 调用wait方法等待任务完成

                joinMe.tryAwaitDone(0L);

                // blockedCount减1，把当前线程标记为活跃状态

                postBlock();

            }

            // 线程处于关闭状态的情况，取消该任务

            else if ((ctl & STOP_BIT) != 0L)

                joinMe.cancelIgnoringExceptions();

        }

    }

    final void tryAwaitDone(long millis) {

        int s;

        try {

            // status为0，设为1。成功了然后才会用wait等待

            if (((s = status) > 0 ||

                 (s == 0 &&

                  UNSAFE.compareAndSwapInt(this, statusOffset, 0, SIGNAL))) &&

                status > 0) {

                synchronized (this) {

                    if (status > 0)

                        wait(millis);

                }

            }

        } catch (InterruptedException ie) {

            // 因为wait被中断了，不能保证任务被正确执行结束，因此调用该方法时要注意

            // 检查任务是否已经执行结束了

    }

    private int externalAwaitDone() {

        int s;

        if ((s = status) >= 0) {

            boolean interrupted = false;

            synchronized (this) {

                // 循环等待直到任务执行结束

                while ((s = status) >= 0) {

                    if (s == 0)

                        UNSAFE.compareAndSwapInt(this, statusOffset,

                                                 0, SIGNAL);

                    else {

                        try {

                            wait();

                        } catch (InterruptedException ie) {

                            interrupted = true;

                        }

                    }

                }

            }

            // 清除中断状态

            if (interrupted)

                Thread.currentThread().interrupt();

        }

        return s;

    }

    private int setCompletion(int completion) {

        for (int s;;) {

            if ((s = status) < 0)

                return s;

            if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {

                if (s != 0)

                    synchronized (this) { notifyAll(); }

                return completion;

            }

        }

    }