Un guide d'utilisation du framework Fork/Join dans la programmation parallèle Java

Java Fork/Join Framework Guide : Créer des tâches Fork/Join : utilisez l'extension de classe RecursiveAction (sans valeur de retour) ou RecursiveTask (avec valeur de retour) pour implémenter la méthode de calcul. Créez un pool Fork/Join : utilisez ForkJoinPool pour spécifier le nombre de threads. Soumettez la tâche : utilisez fork() pour soumettre la tâche et join() pour attendre le résultat. Décomposez la tâche : appelez fork() et join() dans la méthode de calcul pour décomposer la tâche. Cas pratique (tri rapide) : Créez une tâche QuickSortTask et soumettez-la à ForkJoinPool pour exécution.

Guide d'utilisation du framework Fork/Join dans la programmation parallèle Java

Le framework Fork/Join est une méthode de haut niveau pour la parallélisation des tâches dans le modèle de programmation parallèle Java. Il adopte une stratégie diviser pour régner, décomposant les tâches en sous-tâches, puis les exécutant en parallèle et enfin fusionnant les résultats. Ce guide présentera comment utiliser le framework Fork/Join et le démontrera à travers un cas pratique.

Création de tâches Fork/Join

La base du framework Fork/Join est constituée des classes RecursiveAction et RecursiveTask. RecursiveAction 和 RecursiveTask 类。

• RecursiveAction 用于没有返回值的任务。
• RecursiveTask 用于带有返回值的任务。

要创建任务，需要扩展这两种类并实现 compute 方法。compute 方法是任务执行的代码。

创建 Fork/Join 池

Fork/Join 框架使用 ForkJoinPool 对象来管理任务的执行。它是线程池，用于调度和执行任务。创建池时，可以指定线程数量。

ForkJoinPool pool = new ForkJoinPool(Runtime.getRuntime().availableProcessors());

提交任务

要提交任务，请使用 fork() 和 join() 方法。fork() 方法将任务提交到池中，而 join() 方法等待任务完成并返回结果（对于 RecursiveTask 任务）。

pool.fork(task);
long result = pool.join();

分解任务

对于大型任务，可以将其分解成更小的子任务。为此，可以在 compute 方法中调用 fork() 和 join() 方法。

@Override
protected void compute() {
  if (problem.isTooBig()) {
    ForkJoinTask leftTask = new LeftTask(leftHalf);
    ForkJoinTask rightTask = new RightTask(rightHalf);
    leftTask.fork();
    rightTask.fork();
    leftTask.join();
    rightTask.join();
  } else {
    // solve the problem directly
  }
}

实战案例：快速排序

以下是一个使用 Fork/Join 框架的快速排序算法示例：

public class QuickSortTask extends RecursiveTask<long[]> {

  private int[] array;
  private int low;
  private int high;

  public QuickSortTask(int[] array, int low, int high) {
    this.array = array;
    this.low = low;
    this.high = high;
  }

  @Override
  protected long[] compute() {
    if (low < high) {
      int pivot = partition(array, low, high);
      ForkJoinTask leftTask = new QuickSortTask(array, low, pivot - 1);
      ForkJoinTask rightTask = new QuickSortTask(array, pivot + 1, high);
      leftTask.fork();
      rightTask.fork();
      leftTask.join();
      rightTask.join();
    }
    return array;
  }

  private int partition(int[] array, int low, int high) {
    // ...
  }

}

要使用此算法，请创建一个 QuickSortTask 对象并将其提交到 ForkJoinPool：

ForkJoinPool pool = new ForkJoinPool();
int[] array = {5, 3, 8, 2, 1, 4};
QuickSortTask task = new QuickSortTask(array, 0, array.length - 1);
pool.invoke(task);

结论

Fork/Join 框架提供了一种简单易用的方法，用于在 Java 中进行任务并行化。通过分而治之的策略，可以有效地分解大型任务并并行执行。通过使用 RecursiveAction 和 RecursiveTask 类，以及 ForkJoinPool

• RecursiveAction est utilisé pour les tâches qui n'ont pas de valeur de retour.
• RecursiveTask est utilisé pour les tâches avec des valeurs de retour.

Pour créer des tâches, vous devez étendre ces deux classes et implémenter la méthode compute. La méthode compute est le code pour l'exécution des tâches. 🎜🎜🎜Créer un pool Fork/Join🎜🎜🎜Le framework Fork/Join utilise l'objet ForkJoinPool pour gérer l'exécution des tâches. Il s'agit d'un pool de threads utilisé pour planifier et exécuter des tâches. Lors de la création d'un pool, vous pouvez spécifier le nombre de threads. 🎜rrreee🎜🎜Soumettre une tâche🎜🎜🎜Pour soumettre une tâche, utilisez les méthodes fork() et join(). La méthode fork() soumet la tâche au pool, tandis que la méthode join() attend que la tâche se termine et renvoie le résultat (pour une RecursiveTask tâche). 🎜rrreee🎜🎜Décomposez les tâches🎜🎜🎜Pour les tâches volumineuses, divisez-les en sous-tâches plus petites. Pour ce faire, vous pouvez appeler les méthodes <code>fork() et join() dans la méthode compute. 🎜rrreee🎜🎜Cas pratique : Tri rapide🎜🎜🎜Ce qui suit est un exemple d'algorithme de tri rapide utilisant le framework Fork/Join : 🎜rrreee🎜Pour utiliser cet algorithme, créez un objet QuickSortTask et soumettez-le. it To ForkJoinPool : 🎜rrreee🎜🎜Conclusion🎜🎜🎜Le framework Fork/Join fournit un moyen simple et facile de paralléliser des tâches en Java. Grâce à une stratégie diviser pour régner, les tâches importantes peuvent être efficacement réparties et exécutées en parallèle. Les tâches parallèles peuvent être facilement créées et gérées à l'aide des classes RecursiveAction et RecursiveTask, ainsi que de ForkJoinPool. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!