Analyse de l'utilisation d'Executor et de ThreadPool dans la programmation parallèle Java

L'interface Executor fournit un mécanisme d'exécution de tâches, et ThreadPool est son implémentation, gérant le pool de threads pour exécuter les tâches. ThreadPool est créé à l'aide de la classe d'outils Executors, telle que newFixedThreadPool(), et utilise la méthodeexecute() pour soumettre des tâches. Dans un cas pratique, ExecutorService et ThreadPool sont utilisés pour calculer la somme des carrés de nombres afin de démontrer l'utilisation de la programmation parallèle. Les considérations incluent l’équilibrage de la taille du pool de threads et du nombre de tâches, l’évitement des exceptions générées et la fermeture du ThreadPool après utilisation.

Guide d'utilisation d'Executor et ThreadPool dans la programmation parallèle Java

Lors de l'implémentation de la programmation parallèle en Java, Executor et ThreadPool sont les deux concepts de base. Dans ce didacticiel, nous examinerons en profondeur les deux mécanismes et montrerons comment les utiliser à travers des exemples pratiques. L'interface Executor和ThreadPool是两大核心概念。在本教程中，我们将深入探讨这两种机制，并通过实战案例演示如何使用它们。

Executor

Executor接口代表一个任务执行机制。它提供了一个通用的方法execute()，用于提交任务执行。通过实现Executor接口，可以自定义任务的执行方式，例如，创建自定义的线程池或使用现成的线程池。

public class CustomExecutor implements Executor {

    @Override
    public void execute(Runnable command) {
        // 自定义任务执行逻辑
        // ...
    }
}

ThreadPool

ThreadPool是Executor的一个实现，提供了一组线程来并行执行任务。它管理线程的生命周期，确保同时运行的任务数量不超过线程池大小。

可以使用Executors工具类创建线程池，例如newFixedThreadPool()和newCachedThreadPool()：

ExecutorService threadPool = Executors.newFixedThreadPool(5);
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        // 任务代码
    }
});

实战案例

计算数字平方

考虑一个并行计算数字平方和的场景。我们可以使用Executor和ThreadPool实现如下：

import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SquareSum {

    private static int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        long sum = 0;
        for (int number : numbers) {
            threadPool.execute(() -> sum += Math.pow(number, 2));
        }

        threadPool.shutdown();
        while (!threadPool.isTerminated()) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Square sum: " + sum);
    }
}

在这个案例中，Executors.newFixedThreadPool()创建了一个线程池，其大小与可用处理器的数量相匹配。然后，任务被提交到线程池，并行计算每个数字的平方。最后，shutdown()方法关闭了线程池，并等待所有任务完成。

注意事项

• 使用ThreadPool时，应注意线程池大小和任务数量的平衡。线程池过大可能导致资源浪费，而线程池过小可能导致性能瓶颈。
• 提交给Executor的任务不应抛出异常。如果一个任务抛出异常，Executor可能会失败，导致所有其他任务无法执行。
• 在使用ThreadPool后，应使用shutdown()

Executor🎜🎜🎜Executor représente un mécanisme d'exécution de tâches. Il fournit une méthode générale execute() pour soumettre des tâches à exécution. En implémentant l'interface Executor, vous pouvez personnaliser la façon dont les tâches sont exécutées, par exemple en créant un pool de threads personnalisé ou en utilisant un pool de threads prêt à l'emploi. 🎜rrreee🎜🎜ThreadPool🎜🎜🎜ThreadPool est une implémentation de Executor, qui fournit un ensemble de threads pour exécuter des tâches en parallèle. Il gère le cycle de vie des threads et garantit que le nombre de tâches exécutées simultanément ne dépasse pas la taille du pool de threads. 🎜🎜Vous pouvez utiliser la classe d'outils Executors pour créer un pool de threads, tel que newFixedThreadPool() et newCachedThreadPool() : 🎜rrreee🎜🎜 Cas pratique🎜🎜🎜 🎜Calculer le carré d'un nombre🎜🎜🎜Considérons un scénario où la somme des carrés d'un nombre est calculée en parallèle. Nous pouvons utiliser Executor et ThreadPool pour obtenir ce qui suit : 🎜rrreee🎜Dans ce cas, Executors.newFixedThreadPool() crée un pool de threads dont la taille correspond au nombre de processeurs disponibles. Ensuite, la tâche est soumise au pool de threads pour calculer le carré de chaque nombre en parallèle. Enfin, la méthode shutdown() arrête le pool de threads et attend que toutes les tâches soient terminées. 🎜🎜🎜Notes🎜🎜

• Lorsque vous utilisez ThreadPool, vous devez faire attention à l'équilibre entre la taille du pool de threads et le nombre de tâches. Un pool de threads trop grand peut entraîner un gaspillage de ressources, tandis qu'un pool de threads trop petit peut entraîner des goulots d'étranglement en termes de performances. 🎜
• Les tâches soumises à Executor ne doivent pas générer d'exceptions. Si une tâche lève une exception, l'Executor peut échouer, empêchant l'exécution de toutes les autres tâches. 🎜
• Après avoir utilisé ThreadPool, le pool de threads doit être arrêté à l'aide de la méthode shutdown() pour garantir que tous les threads ont été arrêtés. 🎜🎜

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!