Forquilla / Uneix-te marc s'ha introduït en java 7 per resoldre problemes de programació multi-threading / paral·leles.
És molt difícil de tractar concurrent (paral·lel) la programació mitjançant l'ús de manera tradicional. Com que vostè ha de tractar amb sincronització de subprocessos, notificació, unir-se etc i també els perills dels recursos compartits. suport a nivell d'idioma per a la programació concurrent a la plataforma Java és molt fort com ho demostren els esforços en diferents comunitats. Aquestes comunitats tots van tractar de proporcionar models de programació integrals i implementacions eficients que els resums dels punts de dolor associats amb subprocessos múltiples i distribuït Plataforma applications.Java, Standard Edition (Java SE) 5 i després Java SE 6 va introduir un conjunt de paquets (Servei Executor)proporcionar blocs de construcció de gran abast de concurrència. Java SE 7 millorar encara més el marc afegint més suports per al paral·lelisme.
Forquilla / Ingrés és un nou concepte en java 7.0 version. El propòsit bàsic d'aquest marc és facilitar l'entorn multifil en aplicacions java. Com més fi llavors el marc de serveis executor és forquilla / unir-se marc. Els aventatges de tota la potència de processament i, per tant, l'aplicació obté més poder dels recursos i el processament. És una implementació de la interfície ExecutorService que l'ajuda a prendre avantatge dels múltiples processadors. Està dissenyat per a les obres que es poden trencar en trossos més petits de forma recursiva i per tant fer el procés més ràpid.
Similar a ExecutorService, la forquilla / unir-se marc també distribueix tasques als subprocessos de treball en un grup de subprocessos. Però la principal diferència és que la forquilla / unir-se marc utilitza un algoritme de treball a robar. Aquí els subprocessos de treball que s'executen sense coses que fer poden robar les tasques d'altres fils que encara estan ocupats. El ForkJoinPoolclass és una extensió de AbstractExecutorService i el cor del marc. ForkJoinPool implementa l'algoritme de treball a robar nucli i executa ForkJoinTasks.
Ara m'ho dius a mi prendre un exemple per entendre el concepte de detalls.
Els passos bàsics són
· Dividir la tasca
· Assignar als fils disponibles
· Després de la terminació unir-se als trossos i fer que es completi
Prenguem una llista que contindrà gran quantitat de nombres enters generats a l'atzar.
Aquesta classe està mostrant la forma tradicional de fer la tasca.
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;
}
}
Ara la següent classe SplitTask està realitzant la divisió i unir-se a la tasca.
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
protected void còmput() {
si (List.length == 1) {
resultat = llista[0];
} un altre {
int punt mig = List.length / 2;
int[] l1 = Arrays.copyOfRange(llista, 0, punt mig);
int[] L2 = Arrays.copyOfRange(llista, punt mig, List.length);
SplitTask s1 = new SplitTask(l1);
SplitTask s2 = new SplitTask(l2);
forkJoin(s1, s2);
resultat = s1.result + s2.result;
}
}
}
L'última classe està posant a prova el procés. S'invoca la piscina ForkJoinExecutor per realitzar la tasca.
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);
}
}
