Accueil / Concurrency / Files wait/notify vers BlockingQueue
Concurrency Intermédiaire

Files wait/notify vers BlockingQueue

Remplacez la coordination producteur-consommateur écrite à la main par BlockingQueue.

Concurrency
Comparaison de Code
✕ Manual wait and notify 
synchronized (queue) {
    while (queue.isEmpty()) {
        queue.wait();
    }
    Job job = queue.removeFirst();
    process(job);
}
✓ BlockingQueue 
BlockingQueue<Job> queue = new LinkedBlockingQueue<>();

Job job = queue.take();
process(job);
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🛡

Coordination plus sûre

La file gère le verrouillage et la signalisation des conditions.

👁

Intention claire

put() et take() expriment directement le comportement producteur-consommateur.

🎛

Politiques intégrées

Choisissez une capacité bornée, l'équité, des délais ou des opérations non bloquantes.

Ancienne Approche
wait et notify manuels
Approche Moderne
BlockingQueue
Depuis JDK
5
Difficulté
Intermédiaire
Support JDK
Files wait/notify vers BlockingQueue
Disponible

Disponible depuis JDK 5 (2004)

Comment ça fonctionne

Un code wait/notify correct nécessite un moniteur partagé, des boucles de condition, des notifications correspondantes et une gestion soigneuse de l'interruption. BlockingQueue encapsule ces règles et fournit des opérations bloquantes, temporisées et non bloquantes pour les flux producteur-consommateur. Les appels comme put() et take() restent interruptibles.

Documentation Associée
BlockingQueue ↗ LinkedBlockingQueue ↗
Preuve
Voir la preuve source ↗
Patterns associés
Concurrency Débutant

ExecutorService auto-close

Java 8
ExecutorService exec =
    Executors.newCachedThreadPool();
try {
    exec.submit(task);
} finally {
    exec.shutdown();
    exec.awaitTermination(
        1, TimeUnit.MINUTES);
}
Java 19+
try (var exec =
        Executors.newCachedThreadPool()) {
    exec.submit(task);
}
// auto shutdown + await on close
Survolez pour voir le moderne ➜
JDK 19+ →
Concurrency Avancé

Structured concurrency

Java 8
ExecutorService exec =
    Executors.newFixedThreadPool(2);
Future<User> u = exec.submit(this::fetchUser);
Future<Order> o = exec.submit(this::fetchOrder);
try {
    return combine(u.get(), o.get());
} finally { exec.shutdown(); }
Java 25 (Preview)
try (var scope = new StructuredTaskScope
        .ShutdownOnFailure()) {
    var u = scope.fork(this::fetchUser);
    var o = scope.fork(this::fetchOrder);
    scope.join().throwIfFailed();
    return combine(u.get(), o.get());
}
Survolez pour voir le moderne ➜
JDK 25+ →
Concurrency Débutant

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Survolez pour voir le moderne ➜
JDK 21+ →