Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

RecursiveTask — un'attività ricorsiva che restituisce un risultato

RecursiveTask<V> rappresenta un'attività fork/join che restituisce un risultato di tipo V. Il metodo compute() definisce il calcolo: risolve direttamente un problema piccolo oppure lo divide in sottoattività e ne combina i risultati.

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

Sintassi

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> è una classe astratta del pacchetto java.util.concurrent che estende ForkJoinTask<V>. Supporta calcoli di tipo divide et impera che restituiscono un risultato di tipo V. Per le attività senza risultato, l'equivalente è RecursiveAction.

RecursiveTask.compute ha la firma protected abstract V compute(). Una sottoclasse implementa il caso base e la suddivisione del lavoro. Chiamare direttamente compute() è una normale chiamata a un metodo: non invia l'attività a un pool. Nell'esempio, pool.invoke(...) avvia l'attività principale e ne restituisce il risultato.

Uno schema tipico prevede left.fork(), una chiamata diretta a right.compute() e infine left.join(). fork() organizza l'esecuzione asincrona; join() attende, se necessario, e restituisce il risultato. Ciò non significa che venga creato un thread distinto per ogni attività. Le dipendenze di attesa devono essere acicliche per evitare deadlock.

L'esempio somma intervalli disgiunti [from, to) senza modificare l'array. La soglia 2 mostra la suddivisione, ma non è una raccomandazione sulle prestazioni: attività troppo piccole aumentano il sovraccarico. Evita l'I/O bloccante in questi calcoli. Il codice è destinato a Java SE 21; la compatibilità con un ambiente di produzione non è stata attestata.

Esempi

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

Risultato

36

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti