Die Verwendung von ExecutorService und FutureTask in der Java-Parallelprogrammierung

Verwenden Sie ExecutorService, um den Thread-Pool zu verwalten und Aufgaben auszuführen, und verwenden Sie FutureTask, um Aufgaben asynchron auszuführen und ihre Ergebnisse abzurufen. ExecutorService stellt Methoden wie „execute()“ und „submit()“ bereit, und FutureTask stellt die Methoden „get()“, „isDone()“ und „cancel()“ bereit. Praxisbeispiele zeigen, wie man damit parallel Zahlen der Fibonacci-Folge berechnen kann.

Verwendung von ExecutorService und FutureTask in der parallelen Java-Programmierung

Einführung

ExecutorService und FutureTask sind nützliche Tools für die parallele Programmierung in Java. Mit ExecutorService können Sie eine Reihe von Threads verwalten, während Sie mit FutureTask Aufgaben asynchron ausführen und deren Ergebnisse abrufen können.

ExecutorService

ExecutorService ist eine Schnittstelle, die eine Sammlung ausführbarer Thread-Aufgaben darstellt. Sie können verschiedene Implementierungen von ExecutorService erstellen, indem Sie Folgendes verwenden:

ExecutorService executorService = Executors.newFixedThreadPool(5);

wobei 5 die Anzahl der Threads im Thread-Pool darstellt.

ExecutorService bietet die folgenden Methoden zum Ausführen von Aufgaben:

• execute(Runnable task): Führt eine ausführbare Aufgabe aus. execute(Runnable task)：执行一个 Runnable 任务。
• submit(Runnable task)：执行一个 Runnable 任务并返回值。
• submit(Callable<t> task)</t>：执行一个 Callable 任务并返回值。

FutureTask

FutureTask 是一个 Callable 任务的包装器，它允许您异步执行任务并稍后检索其结果。您可以使用以下方法创建 FutureTask：

FutureTask<String> futureTask = new FutureTask<>(() -> "Hello, world!");

其中，() -> "Hello, world!" 是要执行的 Callable 任务。

FutureTask 提供以下方法来检索任务结果：

• get()：阻塞等待任务完成并返回结果。
• isDone()：检查任务是否已完成。
• cancel(boolean mayInterruptIfRunning)
submit(Ausführbare Aufgabe): Eine ausführbare Aufgabe ausführen und einen Wert zurückgeben.

submit(Callable<t> task)</t>: Eine aufrufbare Aufgabe ausführen und einen Wert zurückgeben.

FutureTask

FutureTask ist ein Wrapper um eine aufrufbare Aufgabe, der es Ihnen ermöglicht, eine Aufgabe asynchron auszuführen und ihre Ergebnisse später abzurufen. Sie können eine FutureTask mit der folgenden Methode erstellen: 🎜

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

class FibonacciTask implements Callable<Long> {

    private int n;

    public FibonacciTask(int n) {
        this.n = n;
    }

    @Override
    public Long call() {
        long a = 0;
        long b = 1;
        for (int i = 0; i < n; i++) {
            long temp = a;
            a = b;
            b = temp + b;
        }
        return a;
    }
}

public class Main {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        FutureTask<Long>[] tasks = new FutureTask[10];

        // 创建并提交任务
        for (int i = 0; i < 10; i++) {
            tasks[i] = new FutureTask<>(new FibonacciTask(i));
            executorService.submit(tasks[i]);
        }

        // 获取并打印结果
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("斐波那契数列第 " + i + " 项：" + tasks[i].get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 关闭 ExecutorService
        executorService.shutdown();
    }
}

🎜wobei () -> „Hello, world!“ die auszuführende aufrufbare Aufgabe ist. 🎜🎜FutureTask bietet die folgenden Methoden zum Abrufen von Aufgabenergebnissen: 🎜🎜🎜get(): blockiert das Warten auf den Abschluss der Aufgabe und gibt das Ergebnis zurück. 🎜🎜isDone(): Überprüfen Sie, ob die Aufgabe abgeschlossen wurde. 🎜🎜cancel(boolean mayInterruptIfRunning): Brechen Sie die Aufgabe ab (falls möglich). 🎜🎜🎜🎜Praktischer Fall🎜🎜🎜Stellen Sie sich ein Programm vor, das die Fibonacci-Folge berechnet. Wir können ExecutorService und FutureTask verwenden, um mehrere Fibonacci-Zahlen parallel zu berechnen: 🎜rrreee🎜 In diesem Beispiel haben wir einen ExecutorService erstellt und 10 FibonacciTask-Aufgaben übermittelt. Jede Aufgabe berechnet eine Zahl in der Fibonacci-Folge. Mit FutureTask sind wir in der Lage, diese Aufgaben asynchron auszuführen und ihre Ergebnisse später zu erhalten. 🎜

Das obige ist der detaillierte Inhalt vonDie Verwendung von ExecutorService und FutureTask in der Java-Parallelprogrammierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!