Mi az a Fork/Join keretrendszer, és hogyan használják Java-ban?

A Fork/Join keretrendszer egy specializált végrehajtási keretrendszer, amely hatékonyan párhuzamosítja azokat a feladatokat, amelyek rekurzívan kisebb alfeladatokra bonthatók, majd az eredményeket összekapcsolják (join). Az "oszd meg és uralkodj" elvre épül.

Fő komponensek:

• ForkJoinPool: A szálakból álló pool, amely a feladatok végrehajtását kezeli. A "work-stealing" mechanizmust használja, ahol a inaktív szálak "ellophatnak" feladatokat más elfoglalt szálaktól.
• ForkJoinTask: Egy absztrakt osztály, amely egy ebben a keretrendszerben végrehajtható feladatot reprezentál. Két altípusa van:
  • RecursiveAction: Olyan feladat, amely nem ad vissza eredményt.
  • RecursiveTask<V>: Olyan feladat, amely eredményt ad vissza V típusban.

Használat:

1. Létrehozunk egy osztályt, amely örökli a RecursiveAction vagy RecursiveTask-t.
2. Felülírjuk a compute() metódust. Ebben a metódusban írjuk le a logikát:
   • Ha a feladat elég kicsi (egy bizonyos küszöbérték alatt), akkor közvetlenül végrehajtjuk.
   • Ellenkező esetben, a feladatot alfeladatokra bontjuk, amelyeket az fork() módszerrel aszinkron módon futtatunk.
   • Várjuk az alfeladatok befejeződését a join() módszerrel, és összefoglaljuk az eredményeket.
3. Létrehozunk egy ForkJoinPool példányt.
4. A feladatot a poolba küldjük az invoke() vagy submit() módszerrel.

Példa:

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; // Küszöbérték

    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) {
            // Közvetlen számítás kis tartományokra
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // Feladat felosztása
            int mid = start + (end - start) / 2;
            SumArrayTask leftTask = new SumArrayTask(array, start, mid);
            SumArrayTask rightTask = new SumArrayTask(array, mid, end);

            // Aszinkron végrehajtás
            leftTask.fork();
            Long rightResult = rightTask.compute();
            Long leftResult = leftTask.join();

            // Eredmények összefoglalása
            return leftResult + rightResult;
        }
    }
}

// Használat a fő kódban
// long[] data = new long[10000]; // Kezdő adatok
// // Adatok kitöltése
// ForkJoinPool pool = new ForkJoinPool();
// long sum = pool.invoke(new SumArrayTask(data, 0, data.length));
// pool.shutdown(); // A pool lezárása használat után

Előnyök:

• Automatikus szálkezelés.
• Hatékony terheléselosztás a work-stealing révén.
• Javított teljesítmény "oszd meg és uralkodj" típusú feladatoknál.

Hátrányok:

• Nem minden párhuzamos feladathoz alkalmas.
• Bonyolultabb lehet megvalósítani, mint más megközelítéseket egyszerű feladatok esetén.