Класс RecursiveAction

public abstract class RecursiveAction extends ForkJoinTask<Void>

Рекурсивная задача без результата ForkJoinTask. Этот класс устанавливает соглашения для параметризации действий без результата в виде Void ForkJoinTaskов. Поскольку null — единственное допустимое значение типа Void, такие методы, как join, всегда возвращают null после завершения.

Примеры использования. Ниже приведён простой, но полный пример сортировки с помощью ForkJoin, которая сортирует заданный массив long[]:

static class SortTask extends RecursiveAction {
  final long[] array; final int lo, hi;
  SortTask(long[] array, int lo, int hi) {
    this.array = array; this.lo = lo; this.hi = hi;
  }
  SortTask(long[] array) { this(array, 0, array.length); }
  protected void compute() {
    if (hi - lo < THRESHOLD)
      sortSequentially(lo, hi);
    else {
      int mid = (lo + hi) >>> 1;
      invokeAll(new SortTask(array, lo, mid),
                new SortTask(array, mid, hi));
      merge(lo, mid, hi);
    }
  }
  // implementation details follow:
  static final int THRESHOLD = 1000;
  void sortSequentially(int lo, int hi) {
    Arrays.sort(array, lo, hi);
  }
  void merge(int lo, int mid, int hi) {
    long[] buf = Arrays.copyOfRange(array, lo, mid);
    for (int i = 0, j = lo, k = mid; i < buf.length; j++)
      array[j] = (k == hi || buf[i] < array[k]) ?
        buf[i++] : array[k++];
  }
}

Затем можно отсортировать anArray, создав new SortTask(anArray) и вызвав его в ForkJoinPool. В качестве более конкретного простого примера следующая задача увеличивает каждый элемент массива:

class IncrementTask extends RecursiveAction {
  final long[] array; final int lo, hi;
  IncrementTask(long[] array, int lo, int hi) {
    this.array = array; this.lo = lo; this.hi = hi;
  }
  protected void compute() {
    if (hi - lo < THRESHOLD) {
      for (int i = lo; i < hi; ++i)
        array[i]++;
    }
    else {
      int mid = (lo + hi) >>> 1;
      invokeAll(new IncrementTask(array, lo, mid),
                new IncrementTask(array, mid, hi));
    }
  }
}

В следующем примере показаны некоторые усовершенствования и идиомы, которые могут повысить производительность: RecursiveAction не обязательно должны быть полностью рекурсивными, если они сохраняют базовый подход «разделяй и властвуй». Ниже приведён класс, который суммирует квадраты каждого элемента массива double, разделяя только правые части последовательных делений пополам и отслеживая их с помощью цепочки ссылок next. В нём используется динамический порог, основанный на методе getSurplusQueuedTaskCount, но потенциальное избыточное разбиение компенсируется непосредственным выполнением конечных действий для незахваченных задач вместо дальнейшего разбиения.

double sumOfSquares(ForkJoinPool pool, double[] array) {
  int n = array.length;
  Applyer a = new Applyer(array, 0, n, null);
  pool.invoke(a);
  return a.result;
}

class Applyer extends RecursiveAction {
  final double[] array;
  final int lo, hi;
  double result;
  Applyer next; // keeps track of right-hand-side tasks
  Applyer(double[] array, int lo, int hi, Applyer next) {
    this.array = array; this.lo = lo; this.hi = hi;
    this.next = next;
  }

  double atLeaf(int l, int h) {
    double sum = 0;
    for (int i = l; i < h; ++i) // perform leftmost base step
      sum += array[i] * array[i];
    return sum;
  }

  protected void compute() {
    int l = lo;
    int h = hi;
    Applyer right = null;
    while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
      int mid = (l + h) >>> 1;
      right = new Applyer(array, mid, h, right);
      right.fork();
      h = mid;
    }
    double sum = atLeaf(l, h);
    while (right != null) {
      if (right.tryUnfork()) // directly calculate if not stolen
        sum += right.atLeaf(right.lo, right.hi);
      else {
        right.join();
        sum += right.result;
      }
      right = right.next;
    }
    result = sum;
  }
}