Quels sont les avantages de l'utilisation de la nouvelle fork/join cadre plus simplement, le fractionnement de la tâche, en N sous-tâches dans le début, de les envoyer à une mise en cache du pool de threads (à partir de Exécuteurs) et d'attente pour chaque tâche à accomplir? Je ne vois pas comment à l'aide de la fork/join abstraction simplifie le problème ou rend la solution plus efficace à partir de ce que nous avons eu depuis des années maintenant.
Par exemple, le parallélisée flou de l'algorithme dans le tutoriel exemple pourrait être mis en œuvre comme ceci:
public class Blur implements Runnable {
private int[] mSource;
private int mStart;
private int mLength;
private int[] mDestination;
private int mBlurWidth = 15; // Processing window size, should be odd.
public ForkBlur(int[] src, int start, int length, int[] dst) {
mSource = src;
mStart = start;
mLength = length;
mDestination = dst;
}
public void run() {
computeDirectly();
}
protected void computeDirectly() {
// As in the example, omitted for brevity
}
}
Split, dans le début et d'envoyer des tâches à un pool de threads:
// source image pixels are in src
// destination image pixels are in dst
// threadPool is a (cached) thread pool
int maxSize = 100000; // analogous to F-J's "sThreshold"
List<Future> futures = new ArrayList<Future>();
// Send stuff to thread pool:
for (int i = 0; i < src.length; i+= maxSize) {
int size = Math.min(maxSize, src.length - i);
ForkBlur task = new ForkBlur(src, i, size, dst);
Future f = threadPool.submit(task);
futures.add(f);
}
// Wait for all sent tasks to complete:
for (Future future : futures) {
future.get();
}
// Done!
Les tâches aller pour le pool de threads de la file d'attente, à partir de laquelle ils sont exécutés comme des threads de travail deviennent disponibles. Tant que le fractionnement est granulaire assez (pour éviter d'avoir à en particulier d'attendre la dernière tâche) et le pool de threads a suffisamment (au moins N de processeurs) threads, tous les processeurs sont à fonctionner à pleine vitesse jusqu'à ce que le calcul est fait.
Ai-je raté quelque chose? Quelle est la valeur ajoutée de l'utilisation de la fork/join?
