Files d'attente de tâches en Java : de ThreadPoolExecutor à Disruptor

Files d'attente de tâches en Java : des mécanismes intégrés aux frameworks modernes

Les files d'attente de tâches (Task Queues) sont un modèle fondamental pour construire des applications Java évolutives et tolérantes aux pannes. Elles permettent de séparer la logique métier de la gestion des threads, d'équilibrer la charge et de traiter les tâches de manière asynchrone. Dans cet article, nous analyserons les principales implémentations de files d'attente de tâches en Java, leur architecture, des exemples de code et des scénarios d'utilisation.

1. Mécanismes intégrés : ThreadPoolExecutor et BlockingQueue

La bibliothèque standard Java (java.util.concurrent) offre un ensemble puissant d'outils pour travailler avec les files d'attente de tâches. La base est la classe ThreadPoolExecutor, qui gère un pool de threads et utilise une file d'attente pour stocker les tâches en attente.

Exemple de base :

import java.util.concurrent.*;

public class TaskQueueExample {    public static void main(String[] args) {        // Création d'un pool de threads : corePoolSize=2, maxPoolSize=4, file d'attente de 100 tâches        ThreadPoolExecutor executor = new ThreadPoolExecutor(            2, // corePoolSize            4, // maximumPoolSize            60, // keepAliveTime            TimeUnit.SECONDS,            new LinkedBlockingQueue<>(100) // file d'attente de tâches        );

        // Envoi des tâches        for (int i = 0; i < 10; i++) {            final int taskId = i;            executor.submit(() -> {                System.out.println("Tâche " + taskId + " exécutée par le thread " +                                    Thread.currentThread().getName());                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }            });        }

        // Arrêt correct        executor.shutdown();    }}

Types de files d'attente pour ThreadPoolExecutor :

• LinkedBlockingQueue — file d'attente illimitée basée sur une liste chaînée. Adaptée aux systèmes où le nombre de tâches est inconnu à l'avance.
• ArrayBlockingQueue — file d'attente limitée basée sur un tableau. Permet de contrôler le nombre maximum de tâches en attente.
• SynchronousQueue — file d'attente sans capacité : chaque put() attend un take(). Utilisée pour le transfert direct des tâches aux threads.
• PriorityBlockingQueue — file d'attente avec priorité. Les tâches sont triées selon un comparateur donné.

2. Architecture Producteur-Consommateur basée sur les files d'attente

Le modèle classique Producteur-Consommateur se réalise facilement avec BlockingQueue. Les producteurs placent les tâches dans la file d'attente, et les consommateurs les retirent pour les traiter.

Exemple d'implémentation :

import java.util.concurrent.*;

public class ProducerConsumerExample {    private static final BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);

    static class Producer implements Runnable {        @Override        public void run() {            try {                for (int i = 0; i < 10; i++) {                    String task = "Tâche-" + i;                    queue.put(task); // se bloque si la file est pleine                    System.out.println("Produite : " + task);                    Thread.sleep(100);                }            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }

    static class Consumer implements Runnable {        @Override        public void run() {            try {                while (true) {                    String task = queue.take(); // se bloque si la file est vide                    System.out.printl