Eine Anleitung zur Verwendung des Fork/Join-Frameworks in der parallelen Java-Programmierung

Java Fork/Join Framework-Leitfaden: Fork/Join-Aufgaben erstellen: Verwenden Sie die Klassenerweiterung RecursiveAction (kein Rückgabewert) oder RecursiveTask (mit Rückgabewert), um die Berechnungsmethode zu implementieren. Erstellen Sie einen Fork/Join-Pool: Verwenden Sie ForkJoinPool, um die Anzahl der Threads anzugeben. Senden Sie die Aufgabe: Verwenden Sie fork(), um die Aufgabe zu senden, und join(), um auf das Ergebnis zu warten. Zerlegen Sie die Aufgabe: Rufen Sie fork() und join() in der Compute-Methode auf, um die Aufgabe zu zerlegen. Praktischer Fall (Schnellsortierung): Erstellen Sie eine QuickSortTask-Aufgabe und senden Sie sie zur Ausführung an ForkJoinPool.

Leitfaden zur Verwendung des Fork/Join-Frameworks in der Java-Parallelprogrammierung

Das Fork/Join-Framework ist eine High-Level-Methode für die Aufgabenparallelisierung im Java-Parallelprogrammiermodell. Es verfolgt eine „Teile-und-Herrsche“-Strategie, bei der Aufgaben in Teilaufgaben zerlegt, diese dann parallel ausgeführt werden und schließlich die Ergebnisse zusammengeführt werden. In diesem Leitfaden wird die Verwendung des Fork/Join-Frameworks vorgestellt und an einem praktischen Fall demonstriert.

Erstellen von Fork/Join-Aufgaben

Die Basis des Fork/Join-Frameworks sind die Klassen RecursiveAction und 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 wird für Aufgaben verwendet, die keinen Rückgabewert haben.
• RecursiveTask wird für Aufgaben mit Rückgabewerten verwendet.

Um Aufgaben zu erstellen, müssen Sie diese beiden Klassen erweitern und die Methode compute implementieren. Die compute-Methode ist der Code für die Aufgabenausführung. 🎜🎜🎜Erstellen Sie einen Fork/Join-Pool🎜🎜🎜Das Fork/Join-Framework verwendet das ForkJoinPool-Objekt, um die Ausführung von Aufgaben zu verwalten. Es handelt sich um einen Thread-Pool, der zum Planen und Ausführen von Aufgaben verwendet wird. Beim Erstellen eines Pools können Sie die Anzahl der Threads angeben. 🎜rrreee🎜🎜Eine Aufgabe senden🎜🎜🎜Um eine Aufgabe zu senden, verwenden Sie die Methoden fork() und join(). Die Methode fork() sendet die Aufgabe an den Pool, während die Methode join() auf den Abschluss der Aufgabe wartet und das Ergebnis zurückgibt (für eine RecursiveTask Aufgabe). 🎜rrreee🎜🎜Teilen Sie Aufgaben auf🎜🎜🎜Unterteilen Sie große Aufgaben in kleinere Teilaufgaben. Dazu können Sie die Methoden <code>fork() und join() in der Methode compute aufrufen. 🎜rrreee🎜🎜Praktischer Fall: Schnellsortierung🎜🎜🎜Das Folgende ist ein Beispiel für den Schnellsortierungsalgorithmus unter Verwendung des Fork/Join-Frameworks: 🎜rrreee🎜Um diesen Algorithmus zu verwenden, erstellen Sie ein QuickSortTask-Objekt und senden Sie es ab it Zu ForkJoinPool: 🎜rrreee🎜🎜Fazit🎜🎜🎜Das Fork/Join-Framework bietet eine einfache und unkomplizierte Möglichkeit, Aufgaben in Java zu parallelisieren. Durch eine Divide-and-Conquer-Strategie können große Aufgaben effizient aufgeteilt und parallel ausgeführt werden. Parallele Aufgaben können einfach erstellt und verwaltet werden, indem die Klassen RecursiveAction und RecursiveTask sowie der ForkJoinPool verwendet werden. 🎜

Das obige ist der detaillierte Inhalt vonEine Anleitung zur Verwendung des Fork/Join-Frameworks in der parallelen Java-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!