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)：执行一个 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): Eine aufrufbare Aufgabe ausführen und einen Wert zurückgeben.

FutureTask

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();
    }
}

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!