Java 7: Fourchette / Framework

Fork Join est un nouveau cadre qui a plus de facilité à utiliser API pour un algorithme parallèle, divisée et conquérir.

Disons que vous avez une tâche de course longue qui, pour cette instance, a un algorithme compliqué. Vous voudrez forcer les grandes tâches et travailler maintenant sur ces deux tâches. Disons maintenant que ces deux tâches sont encore trop grandes, vous feriez une fourchette dans deux tâches (à ce stade, il y en a quatre).

Vous continueriez ceci jusqu'à ce que chaque tâche soit à une taille acceptable et invoquez l'algorithme. Il est important de savoir que l'invocation de chaque tâche est effectuée en parallèle. Lorsque la tâche est terminée, elle est jointe à l'autre tâche qu'il a été forcée et consolidez les résultats.

Cela se poursuivra jusqu'à ce que toutes les tâches soient jointes et qu'une tâche soit renvoyée.

En plus de ce qui a déjà été dit, Fork / Rejoindre utilise le vol de travail - Les threads qui manquent de choses à faire peuvent voler des tâches d'autres threads toujours occupés. Et voici un exemple qui peut vous aider à comprendre comment FJ peut être utilisé:

public class SumCounter extends RecursiveTask<Long> { 

  private final Node node; 

  public SumCounter(Node node) { 
    this.node = node; 
  } 

  @Override
  protected Long compute() { 
    long sum = node.getValue();
    List<ValueSumCounter> subTasks = new LinkedList<>(); 

    for(Node child : node.getChildren()) { 
      SumCounter task = new SumCounter(child); 
      task.fork(); // run asynchronously
      subTasks.add(task); 
    }

    for(SumCounter task : subTasks) { 
      sum += task.join(); // wait for the result 
    } 

    return sum;
  }

  public static void main(String[] args) { 
    Node root = getRootNode(); 
    new ForkJoinPool().invoke(new SumCounter(root)); 
  }

}

Je vais répondre à ce que la fourchette rejoint le parallélisme. C'est l'un des motifs de conception parallèles largement utilisés dans de nombreux systèmes pour atteindre la concurrence. Je vais expliquer ce modèle de conception à l'aide d'un exemple.

Par exemple, disons que nous avons un programme qui exécute la séquence de tâches:

A -> B -> C -> D. Ici A, B, C, D sont des tâches.

• A prend 8 secondes
• b prend 4 secondes
• c faut 6 secondes
• d prend 7 secondes

  Il faudra donc au total 8 + 4 + 6 + 7 = 25 secondes pour cette exécution du programme.

  Maintenant, vous avez découvert que les tâches A, B, C sont indépendantes et D dépendent des résultats des tâches B, B. Maintenant, vous pouvez avoir un sentiment que, au lieu d'attendre une finition, nous pouvons commencer l'exécution de b simultanément. Idem pour la tâche c peut démarrer la tâche simultanément avec A et B. Ce que vous pouvez faire est que vous pouvez appeler 3 nouveaux threads par votre fil principal et attribuer-leur des tâches A, B, C et attendez les résultats avant de démarrer l'exécution de la tâche D. Si votre La machine a plusieurs cœurs, alors ces filets peuvent s'exécuter en parallèle.

  Maintenant, le temps d'exécution pris pour le programme est:

  max (time_taken_a, _b, _c) + time_taken_d + threading_overhead_time

  qui est presque égal à = 8 + 7 + k = 15 + k;

  En fourche Joindre le parallélisme Nous pouvons décharger des tâches avec un nouveau fil uniquement si ces tâches sont indépendantes. D'autres sages, nous ferons face à des conditions de course. Si vous avez un programme où une tâche attend une autre exécution de la tâche, cela ne dépend pas de ses résultats, vous pouvez décharger ces deux tâches avec de nouveaux threads à l'aide de Fork Rejoignez le parallélisme et vous pouvez obtenir une amélioration de la performance. Mais pensez toujours à la filetage sur la tête. Si vos tâches sont très légères pondérées, l'utilisation de ces motifs parallèles diminuera vos performances en raison de la création de thread, passez des frais généraux.