Wat is het Fork/Join-framework en hoe wordt het gebruikt in Java?

Het Fork/Join-framework is een gespecialiseerde implementatie van het Executor-framework, ontworpen voor efficiënte parallelisatie van taken die recursief kunnen worden opgesplitst in kleinere subtaken en vervolgens (join) de resultaten worden samengevoegd. Het is gebaseerd op het principe "verdeel en heers" (divide and conquer).

Belangrijke componenten:

• ForkJoinPool: Een threadpool die de uitvoering van taken beheert. Het gebruikt een "work-stealing" mechanisme, waarbij inactieve threads taken kunnen "stelen" van andere bezette threads.
• ForkJoinTask: Een abstracte klasse die een taak vertegenwoordigt die in dit framework kan worden uitgevoerd. Het heeft twee subtypen:
  • RecursiveAction: Taak die geen resultaat retourneert.
  • RecursiveTask<V>: Taak die een resultaat van type V retourneert.

Gebruik:

1. Maak een klasse die erft van RecursiveAction of RecursiveTask.
2. Overschrijf de methode compute(). In deze methode wordt de logica beschreven:
   • Als de taak klein genoeg is (minder dan een drempelwaarde), wordt deze direct uitgevoerd.
   • Anders wordt de taak opgesplitst in subtaken, die asynchroon worden uitgevoerd met fork().
   • Wacht op de voltooiing van de subtaken met join() en combineer de resultaten.
3. Maak een instantie van ForkJoinPool.
4. Dien de taak in bij de pool met invoke() of submit().

Voorbeeld:

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

class SumArrayTask extends RecursiveTask<Long> {
    private final long[] array;
    private final int start;
    private final int end;
    private static final int THRESHOLD = 1000; // Drempelwaarde

    public SumArrayTask(long[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            int mid = start + (end - start) / 2;
            SumArrayTask leftTask = new SumArrayTask(array, start, mid);
            SumArrayTask rightTask = new SumArrayTask(array, mid, end);

            leftTask.fork();
            Long rightResult = rightTask.compute();
            Long leftResult = leftTask.join();

            return leftResult + rightResult;
        }
    }
}

// Gebruik in de hoofdcode
// long[] data = new long[10000]; // Ingangsgegevens
// // Vul data
// ForkJoinPool pool = new ForkJoinPool();
// long sum = pool.invoke(new SumArrayTask(data, 0, data.length));
// pool.shutdown(); // Sluit de pool na gebruik

Voordelen:

• Automatisch beheer van de threadpool.
• Efficiënte verdeling van de belasting dankzij "work-stealing".
• Verbeterde prestaties voor "divide and conquer"-taken.

Nadelen:

• Niet geschikt voor alle soorten parallelle taken.
• Kan moeilijker te implementeren zijn in vergelijking met andere benaderingen voor eenvoudige taken.