Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

RecursiveTask — uma tarefa recursiva que devolve um resultado

RecursiveTask<V> representa uma tarefa fork/join que devolve um resultado do tipo V. O método compute() define o cálculo: resolve diretamente um problema pequeno ou divide-o em subtarefas e combina os respetivos resultados.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

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> é uma classe abstrata do pacote java.util.concurrent que estende ForkJoinTask<V>. Permite cálculos do tipo dividir para conquistar que devolvem um resultado do tipo V. Para tarefas sem resultado, o equivalente é RecursiveAction.

RecursiveTask.compute tem a assinatura protected abstract V compute(). Uma subclasse implementa o caso base e a divisão do trabalho. Chamar diretamente compute() é uma chamada normal a um método: não submete a tarefa a um pool. No exemplo, pool.invoke(...) inicia a tarefa principal e devolve o respetivo resultado.

Um padrão habitual é left.fork(), uma chamada direta a right.compute() e, em seguida, left.join(). fork() organiza a execução assíncrona; join() espera, se necessário, e devolve o resultado. Isto não significa que exista uma thread separada para cada tarefa. As dependências de espera têm de ser acíclicas para evitar deadlocks.

O exemplo soma intervalos disjuntos [from, to) sem modificar o array. O limiar 2 ilustra a divisão, mas não é uma recomendação de desempenho: tarefas demasiado pequenas aumentam a sobrecarga. Evite operações de E/S bloqueantes nestes cálculos. O código destina-se a Java SE 21; a compatibilidade com um ambiente de execução de produção não foi confirmada.

Exemplos

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

Resultado

36

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes