Comment fonctionnent les Executor en Java?

Executor — c’est une interface en Java qui définit un contrat pour exécuter des tâches dans un pool de threads. Au lieu de créer explicitement des threads pour chaque tâche, vous envoyez les tâches aux exécutants, qui gèrent la création, l’utilisation et la destruction des threads.

Les principaux avantages :

• Gestion des threads : Fournit une méthode unifiée pour gérer le pool de threads, évitant la création et la synchronisation manuelles des threads.
• Efficacité : Réutilise les threads existants, réduisant les coûts liés à la création et à la destruction des threads.
• Performance : Améliore la performance et la réactivité des applications grâce à l’exécution asynchrone des tâches.

Executor possède une méthode :

// Exécute la commande donnée à un moment donné dans le futur.
void execute(Runnable command);

Les sous-types couramment utilisés :

• ExecutorService : Étend Executor et fournit des méthodes supplémentaires pour gérer le cycle de vie de l’exécutant et obtenir les résultats des tâches (par exemple, via Future).
• ScheduledExecutorService : Étend ExecutorService et permet d’exécuter des tâches avec un délai ou selon un horaire.

La classe Executors fournit des méthodes de fabrique pour créer différents types d’exécutants :

// Crée un pool de threads avec un nombre fixe de threads.
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

// Crée un pool de threads qui peut ajuster dynamiquement le nombre de threads.
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

// Crée un pool de threads capable d’exécuter des tâches planifiées.
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

Exemple d’utilisation :

// Objet exécuteur
ExecutorService executor = Executors.newFixedThreadPool(2);

// Tâche à exécuter
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Code de la tâche
        System.out.println("Tâche en cours d’exécution dans le thread : " + Thread.currentThread().getName());
    }
};

// Envoyer la tâche à l’exécuteur
executor.execute(task);

// Terminer l’exécuteur (nécessaire pour libérer les ressources)
executor.shutdown();

Lorsqu’on appelle execute(), l’exécuteur prend la tâche (Runnable) et la confie à l’un de ses threads pour l’exécuter. La gestion de la répartition des tâches entre threads et leur cycle de vie est assurée par l’exécuteur.