Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

RecursiveTask — rekurzivní úloha vracející výsledek

RecursiveTask<V> představuje úlohu fork/join, která vrací výsledek typu V. Její metoda compute() určuje výpočet: malý problém vyřeší přímo, nebo jej rozdělí na dílčí úlohy a spojí jejich výsledky.

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

Syntaxe

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> je abstraktní třída z balíčku java.util.concurrent, která rozšiřuje ForkJoinTask<V>. Podporuje výpočty typu rozděl a panuj, které vracejí výsledek typu V. Pro úlohy bez výsledku je protějškem RecursiveAction.

RecursiveTask.compute má signaturu protected abstract V compute(). Podtřída implementuje základní případ a rozdělení práce. Přímé volání compute() je běžné volání metody: úlohu neodesílá do poolu. V příkladu pool.invoke(...) spustí kořenovou úlohu a vrátí její výsledek.

Obvyklý vzor je left.fork(), přímé right.compute() a poté left.join(). fork() zajistí asynchronní provedení; join() v případě potřeby počká a vrátí výsledek. Neznamená to, že každá úloha dostane vlastní vlákno. Závislosti při čekání musí být acyklické, aby se předešlo uváznutí.

Příklad sčítá disjunktní rozsahy [from, to) a nemění přitom pole. Práh 2 ukazuje rozdělení, nejde však o doporučení pro výkon: příliš malé úlohy zvyšují režii. V těchto výpočtech se vyhněte blokujícímu vstupu/výstupu. Kód je určen pro Java SE 21; kompatibilita s produkčním běhovým prostředím nebyla potvrzena.

Příklady

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)));
        }
    }
}

Výsledek

36

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje