Files d'attente de tâches en Java : transformer le chaos en ordre

Quand votre code commence à bégayer : introduction aux files d'attente et tâches en arrière-plan en Java

Imaginez la situation : vous lancez un serveur web en Java. Un utilisateur envoie une requête — il faut envoyer un email, générer un rapport PDF et mettre à jour les statistiques. Si vous exécutez tout de manière synchrone, l'utilisateur attendra 30 secondes. Son café refroidira, et il ira chez vos concurrents. Cela vous dit quelque chose ?

Dans le monde des tâches en arrière-plan Java, cela se résout élégamment : nous plaçons la tâche dans une file d'attente et renvoyons un « 200 OK » à l'utilisateur. Ensuite, en arrière-plan, notre worker traite tranquillement les emails, les PDF et les statistiques. Pas de chaos, seulement de l'ordre.

Aujourd'hui, nous allons voir comment implémenter des files d'attente de tâches en Java — de la version monothread la plus simple aux solutions industrielles avec RabbitMQ et Kafka. Vous apprendrez à arrêter d'éteindre des incendies et à commencer à concevoir des systèmes fiables.

Pourquoi utiliser des files d'attente ? Trois raisons qui vont vous surprendre

\n
1. Asynchronisme — l'utilisateur n'attend pas. Le temps de réponse du serveur passe de 30 secondes à 5 millisecondes.
\n
2. Équilibrage de charge — les pics de requêtes ne font pas planter le serveur. Les tâches sont stockées dans la file d'attente et traitées au fur et à mesure que les ressources se libèrent.
\n
3. Tolérance aux pannes — si un worker tombe, la tâche reste dans la file d'attente. Un autre worker la reprend. Les données ne sont pas perdues.
\n

En Java, il existe des outils intégrés (ExecutorService, BlockingQueue) et des courtiers externes (RabbitMQ, Kafka). Le choix dépend de l'échelle. Commençons par le plus simple.

File d'attente simple en Java : ExecutorService et BlockingQueue

Si vous n'avez pas besoin d'un système distribué, mais simplement de déléguer un travail lourd en arrière-plan — utilisez ThreadPoolExecutor. C'est un pool de threads intégré qui récupère les tâches depuis une file d'attente.

Exemple : pool de threads pour le traitement de commandes

import java.util.concurrent.*;\n\npublic class OrderProcessor {\n    private final ExecutorService executor;\n\n    public OrderProcessor(int threadCount) {\n        // Création d'un pool avec un nombre fixe de threads\n        this.executor = Executors.newFixedThreadPool(threadCount);\n    }\n\n    public void processOrder(Order order) {\n        executor.submit(() -> {\n            // Travail lourd : génération du ticket, envoi d'email, mise à jour du stock\n            System.out.println("Traitement de la commande : " + order.getId());\n            try {\n                Thread.sleep(2000); // simulation du travail\n            } catch (InterruptedException e) {\n                Thread.currentThread().interrupt();\n            }\n            System.out.println("Commande " + order.getId() + " traitée");\n        });\n    }\n\n    public void shutdown() {\n        executor.shutdown();\n    }\n\n    public static void main(String[] args) {\n        OrderProcessor processor = new OrderProcessor(4);\n        for (int i = 0; i < 10; i++) {\n            processor.processOrder(new Order(i));\n        }\n        processor.shutdown();\n    }\n}\n\nclass Order {\n    private final int id;\n    public Order(int id) { this.id = id; }\n    public int getId() { return id; }\n}

Que se passe-t-il ici ? Nous avons créé un pool de 4 threads. 10 commandes seront traitées par lots de 4 en parallèle. La file d'attente de tâches en Java est gérée en interne par ThreadPoolExecutor — il s'agit par défaut d'une LinkedBlockingQueue. Lorsque tous les threads sont occupés, les tâches attendent leur tour.

Configuration avancée : priorités et tolérance aux pannes

Et si certaines tâches sont urgentes ? Utilisez PriorityBlockingQueue :

BlockingQueue<Runnable> priorityQueue = new PriorityBlockingQueue<>(\n    10,\n    Comparator.comparingInt(task -> ((PriorityTask) task).getPriority())\n);\n\nThreadPoolExecutor executor = new ThreadPoolExecutor(\n    2, 4, 60, TimeUnit.SECONDS, priorityQueue\n);

Désormais, les tâches à haute priorité