Čo je Fork/Join rámec a ako sa používa v Jave?

Fork/Join rámec je špecijalizovana implementácia rámca Executor, navrhnutá pre efektívne paralelné rozdeľovanie úloh, ktoré je možné rekurzívne rozdeliť na menšie podúlohy a následne spojiť (join) ich výsledky. Je založený na princípe "rozdeli a panuj".

Kľúčové komponenty:

• ForkJoinPool: Pool vlákien, ktorý riadi vykonávanie úloh. Používa mechanizmus "work-stealing", kde neaktívne vlákna môžu "ukradnúť" úlohy od iných zaneprázdnených vlákien.
• ForkJoinTask: Abstraktná trieda predstavujúca úlohu, ktorá môže byť vykonaná v tomto rámci. Má dve podtriedy:
  • RecursiveAction: Úloha, ktorá nevracia výsledok.
  • RecursiveTask<V>: Úloha, ktorá vracia výsledok typu V.

Použitie:

1. Vytvorí sa trieda, ktorá dedí z RecursiveAction alebo RecursiveTask.
2. Prepisuje sa metóda compute(). V tejto metóde je popísaná logika:
   • Ak je úloha dostatočne malá (menšia ako určitá hranica), je vykonaná priamo.
   • Inak je úloha rozdelená na podúlohy, ktoré sú spustené asynchrónne metódou fork().
   • Čaká sa na dokončenie podúloh metódou join() a ich výsledky sa spoja.
3. Vytvorí sa inštancia ForkJoinPool.
4. Úloha sa odovzdá do poolu pomocou invoke() alebo submit().

Príklad:

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; // Práh

    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) {
            // Priamy výpočet pre malé rozsahy
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // Rozdelenie úlohy
            int mid = start + (end - start) / 2;
            SumArrayTask leftTask = new SumArrayTask(array, start, mid);
            SumArrayTask rightTask = new SumArrayTask(array, mid, end);

            // Asynchrónne spustenie podúloh
            leftTask.fork();
            Long rightResult = rightTask.compute();
            Long leftResult = leftTask.join();

            // Spojenie výsledkov
            return leftResult + rightResult;
        }
    }
}

// Použitie v hlavnom kóde
// long[] data = new long[10000]; // Počiatočné údaje
// // Vyplnenie dát
// ForkJoinPool pool = new ForkJoinPool();
// long sum = pool.invoke(new SumArrayTask(data, 0, data.length));
// pool.shutdown(); // Zatvorenie poolu po použití

Výhody:

• Automatické riadenie poolu vlákien.
• Efektívne rozdeľovanie záťaže vďaka work-stealing-u.
• Zlepšený výkon pre úlohy typu "rozdeliť a panuj".

Nevýhody:

• Nie je vhodný pre všetky typy paralelných úloh.
• Môže byť zložitejší na implementáciu v porovnaní s inými prístupmi pre jednoduché úlohy.