Класс RecursiveAction

public abstract class RecursiveAction extends ForkJoinTask<Void>

Рекурсивная задача без результата ForkJoinTask. Этот класс задаёт соглашения для параметризации действий без результата как Void ForkJoinTasks. Поскольку 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;
  }
}