compact1, compact2, compact3

java.util.concurrent

Класс RecursiveAction

java.lang. Объект

java.util.concurrent. ForkJoinTask<Пусто>

java.util.concurrent. RecursiveAction

Все Реализованные Интерфейсы:

Сериализуемый, Будущий <Пустота>

public abstract class RecursiveAction
extends ForkJoinTask<Void>

Рекурсивный resultless ForkJoinTask. Этот class устанавливает соглашения параметризовать resultless действия как 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:
   final static 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));
     }
   }
 }

Следующий пример иллюстрирует некоторые усовершенствования и идиомы, которые могут привести к лучшей производительности: RecursiveActions не должен быть полностью рекурсивным, пока они поддерживают основной метод разобщения. Вот class, который суммирует квадраты каждого элемента двойного массива, подразделяя только правые стороны повторных подразделений два, и отслеживая их с цепочкой 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;
   }
 }

С тех пор:

1.7

См. Также:

Сериализированная Форма

Сводка конструктора

Конструкторы

Конструктор и Описание
RecursiveAction()

Сводка метода

Модификатор и Тип	Метод и Описание
protected abstract void	compute() Основное вычисление выполняется этой задачей.
protected boolean	exec() Соглашения выполнения реализаций для RecursiveActions.
Пусто	getRawResult() Всегда возвраты null.
protected void	setRawResult(Void mustBeNull) Требует нулевого значения завершения.

Методы, наследованные от class java.util.concurrent. ForkJoinTask

adapt, adapt, adapt, cancel, compareAndSetForkJoinTaskTag, complete, completeExceptionally, fork, get, get, getException, getForkJoinTaskTag, getPool, getQueuedTaskCount, getSurplusQueuedTaskCount, helpQuiesce, inForkJoinPool, invoke, invokeAll, invokeAll, invokeAll, isCancelled, isCompletedAbnormally, isCompletedNormally, isDone, join, peekNextLocalTask, pollNextLocalTask, pollTask, quietlyComplete, quietlyInvoke, quietlyJoin, reinitialize, setForkJoinTaskTag, tryUnfork

Методы, наследованные от class java.lang. Объект

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Деталь конструктора

RecursiveAction

public RecursiveAction()

Деталь метода

вычислить

protected abstract void compute()

Основное вычисление выполняется этой задачей.

getRawResult

public final Void getRawResult()

Всегда возвраты null.

Определенный:

getRawResult в class ForkJoinTask<Void>

Возвраты:

null всегда

setRawResult

protected final void setRawResult(Void mustBeNull)

Требует нулевого значения завершения.

Определенный:

setRawResult в class ForkJoinTask<Void>

Параметры:

mustBeNull - значение

exec

protected final boolean exec()

Соглашения выполнения реализаций для RecursiveActions.

Определенный:

exec в class ForkJoinTask<Void>

Возвраты:

true если эта задача, как известно, обычно завершалась