RecursiveAction Classe

Définition

[Android.Runtime.Register("java/util/concurrent/RecursiveAction", DoNotGenerateAcw=true)]
public abstract class RecursiveAction : Java.Util.Concurrent.ForkJoinTask

[<Android.Runtime.Register("java/util/concurrent/RecursiveAction", DoNotGenerateAcw=true)>]
type RecursiveAction = class
    inherit ForkJoinTask

Héritage

Object

JavaObject

Object

ForkJoinTask

RecursiveAction

Attributs

RegisterAttribute

Remarques

Un résultat ForkJoinTaskrécursif . Cette classe établit des conventions pour paramétrer les actions sans résultat en tant que VoidForkJoinTasks. Étant donné qu’il null s’agit de la seule valeur valide de type Void, les méthodes telles que join toujours retourner null à la fin.

<b>Exemples d’utilisations.</b> Voici un tri ForkJoin simple mais complet qui trie un tableau donné long[] :

{@code
            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++];
              }
            }}

Vous pouvez ensuite trier anArray en créant new SortTask(anArray) et en l’appelant dans un ForkJoinPool. Comme exemple plus concret, la tâche suivante incrémente chaque élément d’un tableau :

{@code
            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));
                }
              }
            }}

L’exemple suivant illustre quelques affinements et idiomes qui peuvent entraîner de meilleures performances : Les récursiveActions n’ont pas besoin d’être entièrement récursives, tant qu’elles maintiennent l’approche de base de division et de conquête. Voici une classe qui additionne les carrés de chaque élément d’un tableau double, en subdivisant uniquement les côtés droit des divisions répétées par deux, et en les faisant suivre avec une chaîne de next références. Il utilise un seuil dynamique basé sur la méthode getSurplusQueuedTaskCount, mais contrebalance le partitionnement excessif potentiel en effectuant directement des actions feuille sur des tâches non exécutées au lieu de subdivider davantage.

{@code
            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;
              }
            }}

Ajouté dans la version 1.7.

Documentation Java pour java.util.concurrent.RecursiveAction.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.