Comprendre les pools de threads, les threads de travail et les types de pools de threads

La concurrence et le parallélisme sont essentiels pour créer des applications efficaces et réactives. Dans la programmation moderne, les pools de threads constituent un outil puissant pour gérer et exécuter des tâches simultanément. Dans cet article de blog, nous explorerons ce que sont les pools de threads, les types de pools de threads disponibles et comment les threads de travail jouent un rôle crucial dans leur fonctionnalité.

Qu’est-ce qu’un pool de threads ?

Un pool de threads est un ensemble de threads de travail pré-initialisés qui peuvent exécuter des tâches simultanément. Au lieu de créer un nouveau thread pour chaque tâche, les tâches sont soumises au pool de threads, qui gère l’exécution des tâches à l’aide des threads disponibles. Cette approche offre plusieurs avantages :

• Efficacité: La réutilisation des threads réduit la surcharge liée à la création et à la destruction des threads pour chaque tâche.
• La gestion des ressources: La limitation du nombre de threads contrôle les ressources système utilisées.
• Contrôle de la concurrence: Le pool peut gérer plusieurs tâches simultanément, offrant de meilleures performances et réactivité.

Le diagramme ci-dessous explique brièvement comment une application en cours d’exécution soumet les tâches à une file d’attente qui occupe un thread disponible du « pool de threads » pour exécuter cette tâche de manière asynchrone.

Comprendre les threads de travail

Les threads de travail sont les threads d’un pool de threads qui exécutent des tâches. Voici comment ils fonctionnent :

• Attribution de tâche: Les threads de travail se voient attribuer des tâches à partir de la file d’attente du pool de threads et sont exécutés simultanément.
• Exécution des tâches : Chaque thread de travail exécute la tâche qui lui est assignée indépendamment, permettant un traitement parallèle des tâches.
• Réutilisation: Une fois qu’un thread de travail termine une tâche, il redevient disponible pour entreprendre une autre tâche de la file d’attente.

Types de pools de threads

Il existe différents types de pools de threads qui peuvent être utilisés en fonction du cas d’utilisation.

1. Pool de threads de taille fixe

Un pool de threads de taille fixe s’initialise avec un nombre spécifique de threads de travail. Ce nombre reste constant tout au long du cycle de vie de la piscine.

Exemple:

import java.util.concurrent.*;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // Create a fixed-size thread pool with 4 threads
        ExecutorService threadPool = Executors.newFixedThreadPool(4);

        // Submit tasks to the thread pool
        for (int i = 1; i <= 5; i++) {
            final int taskNumber = i;
            threadPool.execute(() -> {
                System.out.println("Executing task " + taskNumber + " on thread: " + Thread.currentThread().getName());
            });
        }

        // Shut down the thread pool once tasks are complete
        threadPool.shutdown();
    }
}

import java.util.concurrent.*;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        // Create a cached thread pool
        ExecutorService threadPool = Executors.newCachedThreadPool();

        // Submit tasks to the thread pool
        for (int i = 1; i <= 5; i++) {
            final int taskNumber = i;
            threadPool.execute(() -> {
                System.out.println("Executing task " + taskNumber + " on thread: " + Thread.currentThread().getName());
            });
        }

        // Shut down the thread pool once tasks are complete
        threadPool.shutdown();
    }
}

import java.util.concurrent.*;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        // Create a scheduled thread pool with 2 threads
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(2);

        // Schedule tasks to run at fixed-rate intervals
        Runnable task = () -> {
            System.out.println("Running task on thread: " + Thread.currentThread().getName());
        };
        threadPool.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);

        // The thread pool continues to run the task at fixed intervals
        // It can be shut down after a certain period, depending on your use case
    }
}