KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

ForkJoinPool — een pool voor taken die in deeltaken zijn opgesplitst

ForkJoinPool voert taken uit met work-stealing. Lees meer over synchrone invoke, de gedeelde commonPool en de regels voor het afsluiten van een eigen pool met shutdown.

Versie: Documentation scope: Java SE 21; neither the repository runtime nor the production runtime is attested.

Syntax

new ForkJoinPool(int parallelism)
<T> T ForkJoinPool.invoke(ForkJoinTask<T> task)
static ForkJoinPool ForkJoinPool.commonPool()
void ForkJoinPool.shutdown()

ForkJoinPool voert ForkJoinTask-taken uit met work-stealing: inactieve threads nemen beschikbaar werk over. De pool is geschikt voor berekeningen die in deeltaken zijn opgesplitst; blokkerende I/O kan de voortgang beperken.

ForkJoinPool.invoke wacht op het resultaat van een taak en geeft de ongecontroleerde uitzonderingen of fouten ervan door. ForkJoinPool.commonPool retourneert een gedeelde pool; een eigen pool maakt afzonderlijk resourcebeheer mogelijk.

ForkJoinPool.shutdown weigert nieuwe taken in een eigen pool, maar laat eerder geaccepteerde taken afronden. De methode wacht niet tot ze klaar zijn. De gedeelde pool wordt niet afgesloten. Gebruik awaitTermination om na het afsluiten te wachten.

Het voorbeeld telt de getallen 1 tot en met 8 op: fork() maakt het linkerdeel beschikbaar, en join() haalt het resultaat ervan op. Documentatiebereik: Java SE 21; de runtime van de repository en de productie-runtime zijn niet bevestigd.

Voorbeelden

import java.util.concurrent.ForkJoinPool;
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 middle = from + (to - from) / 2;
            Sum left = new Sum(from, middle);
            Sum right = new Sum(middle, to);
            left.fork();
            int rightResult = right.compute();
            return left.join() + rightResult;
        }
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool(2);
        try {
            System.out.println(pool.invoke(new Sum(1, 9)));
        } finally {
            pool.shutdown();
        }
    }
}

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