Quand dois-je utiliser SynchronousQueue plutôt que LinkedBlockingQueue ?

Question

new SynchronousQueue()
new LinkedBlockingQueue(1)

Quelle est la différence ? Quand dois-je utiliser SynchronousQueue contre LinkedBlockingQueue avec la capacité 1 ?

Answer 1

Les files d'attente synchrones sont essentiellement utilisées à des fins de transfert. Elles n'ont pas de capacité et une opération put est bloquée jusqu'à ce qu'un autre thread effectue une opération get.

Si nous voulons partager en toute sécurité une variable entre deux threads, nous pouvons placer cette variable dans une file d'attente synchrone et laisser l'autre thread la prendre dans la file d'attente.

Exemple de code de https://www.baeldung.com/java-synchronous-queue

    ExecutorService executor = Executors.newFixedThreadPool(2);
    SynchronousQueue<Integer> queue = new SynchronousQueue<>();
Runnable producer = () -> {
    Integer producedElement = ThreadLocalRandom
      .current()
      .nextInt();
    try {
        queue.put(producedElement);
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    }
};

Runnable consumer = () -> {
    try {
        Integer consumedElement = queue.take();
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    }
};

executor.execute(producer);
executor.execute(consumer);

executor.awaitTermination(500, TimeUnit.MILLISECONDS);
executor.shutdown();
assertEquals(queue.size(), 0);

Ils sont également utilisés dans CachedThreadPool pour obtenir un effet de création illimitée (Integer.MAX) de threads à mesure que les tâches arrivent. CachedPool a un coreSize de 0 et un maxPoolSize de Integer.MAX avec une file d'attente synchrone.

À mesure que les tâches arrivent dans la file d'attente, les autres tâches sont bloquées jusqu'à ce que la première soit extraite. Puisqu'il n'a pas de capacité de file d'attente, le pool de threads créera un thread et ce thread prendra la tâche permettant à d'autres tâches d'être placées dans la file d'attente. Cela continuera jusqu'à ce que la création de threads atteigne maxPoolSize. En fonction du timeOut, les threads inactifs peuvent être terminés et de nouveaux sont créés sans dépasser la maxPoolSize.