KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

RecursiveTask — een recursieve taak met resultaat

RecursiveTask<V> stelt een fork/join-taak voor die een resultaat van het type V teruggeeft. De methode compute() beschrijft de berekening: los een klein probleem direct op of splits het op in subtaken en combineer hun resultaten.

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

Syntax

class Task extends RecursiveTask<Result> {
    @Override
    protected Result compute() {
        // Replace this placeholder with a base-case return or a return that combines subtask results.
        throw new UnsupportedOperationException("Implement compute()");
    }
}

RecursiveTask<V> is een abstracte klasse uit java.util.concurrent die ForkJoinTask<V> uitbreidt. De klasse ondersteunt verdeel-en-heersberekeningen die een resultaat van het type V teruggeven. Voor taken zonder resultaat is RecursiveAction het equivalent.

RecursiveTask.compute heeft de signatuur protected abstract V compute(). Een subklasse implementeert het basisgeval en de verdeling van het werk. Een directe aanroep van compute() is een gewone methodeaanroep: de taak wordt niet bij een pool ingediend. In het voorbeeld start pool.invoke(...) de hoofdtaak en geeft het resultaat terug.

Een gebruikelijk patroon is left.fork(), een directe aanroep van right.compute() en daarna left.join(). fork() regelt asynchrone uitvoering; join() wacht indien nodig en geeft het resultaat terug. Dit betekent niet dat er voor elke taak een aparte thread is. Wachtende afhankelijkheden moeten acyclisch zijn om deadlocks te voorkomen.

Het voorbeeld telt disjuncte bereiken [from, to) op zonder de array te wijzigen. De drempel 2 laat het opsplitsen zien, maar is geen aanbeveling voor prestaties: te kleine taken verhogen de overhead. Vermijd blokkerende I/O in deze berekeningen. De code is bedoeld voor Java SE 21; compatibiliteit met een productie-runtime is niet bevestigd.

Voorbeelden

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

public class RecursiveTaskDemo {
    static final class SumTask extends RecursiveTask<Long> {
        private final int[] values;
        private final int from;
        private final int to;

        SumTask(int[] values, int from, int to) {
            this.values = values;
            this.from = from;
            this.to = to;
        }

        @Override
        protected Long compute() {
            if (to - from <= 2) {
                long sum = 0;
                for (int i = from; i < to; i++) {
                    sum += values[i];
                }
                return sum;
            }
            int mid = from + (to - from) / 2;
            SumTask left = new SumTask(values, from, mid);
            SumTask right = new SumTask(values, mid, to);
            left.fork();
            long rightSum = right.compute();
            return rightSum + left.join();
        }
    }

    public static void main(String[] args) {
        int[] values = {1, 2, 3, 4, 5, 6, 7, 8};
        try (ForkJoinPool pool = new ForkJoinPool(2)) {
            System.out.println(pool.invoke(new SumTask(values, 0, values.length)));
        }
    }
}

Resultaat

36

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen