Files d'attente de tâches en Java : guide complet avec exemples

Files d'attente de tâches en Java : des bases aux solutions multithread

La file d'attente de tâches (Task Queue) est l'un des modèles fondamentaux du développement logiciel. En Java, ce mécanisme est implémenté via l'interface Queue et ses nombreuses implémentations. La file d'attente permet d'organiser le traitement des tâches dans l'ordre de leur arrivée (FIFO — First In, First Out), ce qui est particulièrement important pour travailler avec des pools de threads, des opérations asynchrones et des systèmes distribués.

Dans cet article, nous allons détailler comment travailler avec les files d'attente de tâches en Java : de l'interface de base aux implémentations multithread avancées. Vous découvrirez quelles classes utiliser dans différents scénarios et comment éviter les erreurs typiques.

1. Interface Queue et opérations de base

L'interface Queue fait partie du Java Collections Framework. Elle définit les méthodes principales pour travailler avec une file d'attente :

• add(E e) — ajoute un élément, lève une exception en cas de dépassement de capacité ;
• offer(E e) — ajoute un élément, retourne false en cas d'échec ;
• remove() — supprime et retourne l'élément en tête, lève une exception si la file est vide ;
• poll() — supprime et retourne l'élément en tête, retourne null si la file est vide ;
• element() — retourne l'élément en tête sans le supprimer, lève une exception si la file est vide ;
• peek() — retourne l'élément en tête sans le supprimer, null si la file est vide.

Exemple de travail de base avec une file d'attente :

import java.util.LinkedList;import java.util.Queue;

public class SimpleQueueExample {    public static void main(String[] args) {        Queue<String> taskQueue = new LinkedList<>();

        // Ajout de tâches        taskQueue.offer("Tâche 1 : Traitement de commande");        taskQueue.offer("Tâche 2 : Envoi d'email");        taskQueue.offer("Tâche 3 : Génération de rapport");

        System.out.println("Tâche actuelle : " + taskQueue.peek());        System.out.println("Taille de la file : " + taskQueue.size());

        // Traitement de toutes les tâches        while (!taskQueue.isEmpty()) {            String task = taskQueue.poll();            System.out.println("Exécution : " + task);        }    }}

Résultat de l'exécution :

Tâche actuelle : Tâche 1 : Traitement de commandeTaille de la file : 3Exécution : Tâche 1 : Traitement de commandeExécution : Tâche 2 : Envoi d'emailExécution : Tâche 3 : Génération de rapport

2. Implémentations principales des files d'attente

Java propose plusieurs implémentations de l'interface Queue, chacune adaptée à des scénarios spécifiques.

2.1. LinkedList comme file d'attente

LinkedList est l'une des implémentations les plus simples et polyvalentes. Elle fonctionne comme une liste doublement chaînée, permettant d'ajouter et de supprimer rapidement des éléments aux deux extrémités. Cependant, pour de grands volumes de données, les performances peuvent diminuer en raison des frais généraux liés au stockage des références.

Queue<Integer> linkedQueue = new LinkedList<>();linkedQueue.add(10);linkedQueue.add(20);linkedQueue.add(30);System.out.println(linkedQueue.poll()); // 10

2.2. PriorityQueue — file d'attente avec priorités

PriorityQueue ne respecte pas un ordre FIFO strict. Les éléments sont extraits dans l'ordre de leur priorité, définie soit par l'ordre naturel (Comparable), soit par un comparateur. C'est un choix idéal pour les systèmes où certaines tâches sont plus importantes que d'autres.

import java.util.PriorityQueue;import java.util.Queue;

public class PriorityQueueExample {    public static void main(String[] args) {        Queue<Task> priorityQueue = new PriorityQueue<>(            (t1, t2) -> Integer.compare(t1.priority, t2.priority)        );

        // Ajout de tâches avec différentes priorités        priorityQueue.offer(new Task("Tâche normale", 5));        priorityQueue.offer(new Task("Tâche urgente", 1));        priorityQueue.offer(new Task("Tâche de routine", 10));

        while (!priorityQueue.isEmpty()) {            System.out.println(priorityQueue.poll());        }    }}

class Task {    String name;    int priority;

    Task(String name, int priority) {        this.name = name;        this.priority = priority;    }

    @Override    public String toString() {        return name + " (priorité : " + priority + ")";    }}

Résultat de l'exécution :

Tâche urgente (priorité : 1)Tâche normale (priorité : 5)Tâche de routine (priorité : 10)