Fork / Join quadro è stato introdotto in Java 7 per risolvere multi-threading / problemi di programmazione parallela.
E 'molto difficile da affrontare concomitante (parallelo) programmazione utilizzando modo tradizionale. Perché hai a che fare con la sincronizzazione dei thread, notifica, unire ecc e anche le insidie di risorse condivise. supporto a livello di lingua per la programmazione concorrente sulla piattaforma Java è molto forte, come dimostrato dagli sforzi in diverse comunità. Queste comunità tutti hanno cercato di fornire modelli di programmazione complete e implementazioni efficienti che astrae i punti di dolore associato con la piattaforma multi-threaded e distribuito applications.Java, edizione standard (Java SE) 5 e poi Java SE 6 ha introdotto una serie di pacchetti (servizio di esecutore)fornendo elementi di forte concorrenza. Java SE 7 ulteriormente migliorato il quadro l'aggiunta di ulteriori supporti per il parallelismo.
Fork / Join è un nuovo concetto di Java 7.0 version. Lo scopo fondamentale di questo quadro è quello di facilitare l'ambiente multithreading nelle applicazioni Java. Il più fine poi il quadro di servizio esecutore è forcella quadro / unirsi. Ci vogliono i vantaggi di tutta la potenza di elaborazione e, quindi, l'applicazione diventa più risorse e potenza di elaborazione. Si tratta di una implementazione dell'interfaccia ExecutorService che consente di sfruttare più processori. È stato progettato per lavori che possono essere suddivisi in piccoli pezzi in modo ricorsivo e quindi rendere l'elaborazione più veloce.
Simile a ExecutorService, la forcella / join quadro distribuisce anche i compiti a thread di lavoro in un pool di thread. Ma la differenza principale è che la forcella / unirsi al quadro usa un algoritmo di lavoro furto. Qui i thread di lavoro che a corto di cose da fare possono rubare i compiti da altri thread che sono ancora occupati. Il ForkJoinPoolclass è un'estensione del AbstractExecutorService e il cuore del quadro. ForkJoinPool implementa l'algoritmo di lavoro furto di base ed esegue ForkJoinTasks.
Ora mi permetta di prendere un esempio per capire il concetto in dettaglio.
I passi fondamentali sono
· Dividere il compito
· Assegnarlo al thread disponibili
· Dopo il completamento unire i pezzi e renderla completa
Prendiamo un elenco che conterrà gran numero di interi generati a caso.
Questa classe sta mostrando il modo tradizionale di fare il compito.
package javablog.levent.com;
import java.util.Random;
// This class defins a list which will contain large number of integers.
public class LargeInteger {
private final int[] list = new int[2000000];
public largeInteger() {
Random generator = new Random(19580427);
for (int i = 0; i < list.length; i++) {
list[i] = generator.nextInt(500000);
}
}
public int[] getList() {
return list;
}
}
Ora la seguente classe SplitTask sta eseguendo la scissione e unirsi compito.
package javablog.levent.com;
import java.util.Arrays;
import jsr166y.forkjoin.RecursiveAction;
public class SplitTask extends RecursiveAction {
private int[] list;
public long result;
public SplitTask(int[] array) {
this.list = array;
}
@ Override
protetta calcolo vuoto() {
se (List.length == 1) {
risultato = lista[0];
} altro {
int punto medio = List.length / 2;
int[] L1 = Arrays.copyOfRange(lista, 0, punto medio);
int[] L2 = Arrays.copyOfRange(lista, punto medio, List.length);
SplitTask s1 = new SplitTask(l1);
SplitTask s2 = new SplitTask(l2);
forkJoin(s1, s2);
risultato = s1.result + s2.result;
}
}
}
L'ultima classe sta testando il processo. Si invoca la piscina ForkJoinExecutor per eseguire l'operazione.
package javablog.levent.com;
import jsr166y.forkjoin.ForkJoinExecutor;
import jsr166y.forkjoin.ForkJoinPool;
import javablog.levent.com.SplitTask;
public class TestForkJoin {
public static void main(String[] args) {
LargeInteger test = new LargeInteger();
// Check the number of available processors
int nThreads = Runtime.getRuntime().availableProcessors();
System.out.println(nThreads);
SplitTask mfj = new SplitTask(test.getList());
ForkJoinExecutor pool = new ForkJoinPool(nThreads);
pool.invoke(mfj);
long result = mfj.getResult();
System.out.println("Done. Result: " + result);
}
}
