WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

ForkJoinTask — Berechnungen aufteilen und Ergebnisse zusammenführen

ForkJoinTask steht für eine Aufgabe, die von ForkJoinPool ausgeführt wird. Lerne anhand eines Beispiels, das eine Summe in Teilaufgaben zerlegt, wie du mit fork() Aufgaben einplanst, mit join() Ergebnisse abrufst und mit invokeAll() mehrere Aufgaben gemeinsam ausführst.

Version: Java SE 21; repository runtime, production runtime not attested

Syntax

ForkJoinTask<V> task;
ForkJoinTask<V> scheduled = task.fork();
V result = task.join();
ForkJoinTask.invokeAll(task1, task2);

ForkJoinTask<V> ist eine abstrakte Aufgabe für ForkJoinPool. Für Berechnungen, die ein Ergebnis zurückgeben, erweitert man üblicherweise RecursiveTask<V> und implementiert compute(). Der Pool teilt Threads zwischen Aufgaben auf; eine Aufgabe bedeutet nicht, dass ein eigener Thread entsteht.

ForkJoinTask.fork() plant die Ausführung im aktuellen Pool ein oder außerhalb eines Pools in ForkJoinPool.commonPool(). ForkJoinTask.join() wartet auf das Ergebnis; die Methode löst kein InterruptedException aus und gibt Fehler als ungeprüfte Ausnahmen weiter.

ForkJoinTask.invokeAll() startet eine Gruppe von Aufgaben und wartet auf deren Abschluss oder auf eine Ausnahme. Nach einer Ausnahme können andere Aufgaben abgebrochen werden; der Abschluss jeder Aufgabe ist nicht garantiert. Rufe die Ergebnisse mit join() ab.

Vermeide blockierende I/O-Vorgänge und zyklische Abhängigkeiten zwischen Aufgaben. Im Beispiel startet pool.invoke(root) die Berechnung in einem dedizierten Pool. Sum teilt einen Bereich in zwei Hälften, berechnet eine Hälfte lokal und führt die Ergebnisse zusammen; invokeAll() koordiniert die beiden Teile. Der kleine Schwellenwert für die Aufteilung dient der Demonstration, nicht der Leistungsmessung.

Beispiele

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class Main {
    static final class Sum extends RecursiveTask<Integer> {
        private final int from;
        private final int to;

        Sum(int from, int to) {
            this.from = from;
            this.to = to;
        }

        @Override
        protected Integer compute() {
            if (to - from <= 2) {
                int total = 0;
                for (int i = from; i < to; i++) {
                    total += i;
                }
                return total;
            }
            int mid = from + (to - from) / 2;
            Sum left = new Sum(from, mid);
            Sum right = new Sum(mid, to);
            left.fork();
            int rightResult = right.compute();
            return left.join() + rightResult;
        }
    }

    public static void main(String[] args) {
        try (ForkJoinPool pool = new ForkJoinPool(2)) {
            ForkJoinTask<Integer> root = new RecursiveTask<Integer>() {
                @Override
                protected Integer compute() {
                    Sum first = new Sum(1, 5);
                    Sum second = new Sum(5, 9);
                    ForkJoinTask.invokeAll(first, second);
                    return first.join() + second.join();
                }
            };
            System.out.println(pool.invoke(root));
        }
    }
}

Ergebnis

36

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen