并行编程。 compute（）方法，java

Question

I have this class which extends RecursiveAction . that same class contains constructor which takes array as argument and compute() method. Inside compute method, it says next: if array length is bigger than 500, split that array in two halves and sort them by MergeSort.merge() method. if array length is less than 500, just sort the array .

private static class SortTask extends RecursiveAction {
   private final int THRESHOLD = 500;
     private int[] list;
      SortTask(int[] list) {
       this.list = list;
         }
        @Override
protected void compute() {
if (list.length < THRESHOLD)
java.util.Arrays.sort(list);
else {
    // Obtain the first half
int[] firstHalf = new int[list.length / 2];
System.arraycopy(list, 0, firstHalf, 0, list.length / 2);


// Obtain the second half
int secondHalfLength = list.length - list.length / 2;
int[] secondHalf = new int[secondHalfLength];
System.arraycopy(list, list.length / 2,
secondHalf, 0, secondHalfLength);
// Recursively sort the two halves
invokeAll(new SortTask(firstHalf),
new SortTask(secondHalf));
// Merge firstHalf with secondHalf into list
MergeSort.merge(firstHalf, secondHalf, list);
}
}
}
}

It says "recursively sort the two halves" and it does that by:

invokeAll(new SortTask(firstHalf), new SortTask(secondHalf));

does that mean that every time new SortTask object is created, compute() method is called ?

Answer 1

The answer is No. Compute is not a part of Task constructor. The simpliest situation is pool shutdownNow() - this call will try to terminate/interrupt all submited tasks.

Every time new SortTask created ForkJoinPool forks this task:

public static void invokeAll(ForkJoinTask<?>... tasks) {
    Throwable ex = null;
    int last = tasks.length - 1;
    for (int i = last; i >= 0; --i) {
        ForkJoinTask<?> t = tasks[i];
        if (t == null) {
            if (ex == null)
                ex = new NullPointerException();
        }
        else if (i != 0)
            t.fork();
    ...
}

compute method is your task payload - ForkJoinPool will do it on it's schedule .

From ForkJoinTask javadoc :

The primary coordination mechanisms are fork(), that arranges asynchronous execution, and join(), that doesn't proceed until the task's result has been computed.

RecursiveTask implements abstract method:

protected final boolean exec() {
    result = compute();
    return true;
}

ForkJoinWorkerThread has method:

final void More execTask(ForkJoinTask<?> t) {
    currentSteal = t;
    for (;;) {
       if (t != null)
           t.doExec();
    ...
}

and at the and doExec calls exec

final void doExec() {
    if (status >= 0) {
        boolean completed;
        try {
            completed = exec();
    ...
}

Answer 2

Yes, every time new SortTask object is created, compute() method is called, because the method invokeAll forkes a set of tasks in a ForkJoinPool which implicitly calls compute for each one of them.

Method invoke() is semantically equivalent to fork(); join() but always attempts to begin execution in the current thread.

Also from the documentation:

Normally, a concrete ForkJoinTask subclass (RecursiveAction/RecursiveTask) declares fields comprising its parameters, established in a constructor, and then defines a compute method that somehow uses the control methods supplied by this base class.

The method used to sort them here actually is to recursively divide them that when they reach the THRESHOLD they will be sorted sequentially, the merge method is used to merge them after they get sorted. Look at this similar example:

class SortTask extends RecursiveAction {
final long[] array; final int lo; final int hi;
SortTask(long[] array, int lo, int hi) {
this.array = array; this.lo = lo; this.hi = hi;
}
protected void compute() {
 if (hi - lo < THRESHOLD)
   sequentiallySort(array, lo, hi);
  else {
   int mid = (lo + hi) >>> 1;
    coInvoke(new SortTask(array, lo, mid),
            new SortTask(array, mid+1, hi));
   merge(array, lo, hi);
       }
return null;
}
}

When coInvoke here Forks both tasks and returns when isDone holds for both.