Implémentation de BlockingQueue: quelles sont les différences entre Synchrousqueue et LinkedBlockingQueue

SynchronousQueue est un type de file d'attente très spécial-il implémente une approche de rendez-vous (le producteur attend que le consommateur soit prêt, le consommateur attend que le producteur soit prêt) derrière l'interface de Queue.

Par conséquent, vous pouvez en avoir besoin uniquement dans les cas particuliers lorsque vous avez besoin de cette sémantique particulière, par exemple, threading unique d'une tâche sans mettre en file d'attente d'autres demandes.

Une autre raison d'utiliser SynchronousQueue est la performance. La mise en œuvre de SynchronousQueue semble être fortement optimisé, donc si vous n'avez besoin de rien de plus qu'un point de rendez-vous (comme dans le cas de Executors.newCachedThreadPool(), où les consommateurs sont créés "à la demande", de sorte que les éléments de file d'attente ne s'accumulent pas), vous pouvez obtenir un gain de performance en utilisant SynchronousQueue.

Un test synthétique simple montre que dans un scénario simple producteur-consommateur unique sur une machine dual-core, le débit de SynchronousQueue est ~20 fois plus élevé que le débit de LinkedBlockingQueue et ArrayBlockingQueue avec une longueur de file d'attente = 1. Lorsque la longueur de la file d'attente est augmentée, leur débit augmente et atteint presque le débit de SynchronousQueue. Cela signifie que SynchronousQueue a une faible surcharge de synchronisation sur les machines multi-cœurs par rapport aux autres Files d'attente. Mais encore une fois, cela n'a d'importance que dans des circonstances spécifiques lorsque vous avez besoin d'un point de rendez-vous déguisé en Queue.

Modifier:

Voici un test:

public class Test {
    static ExecutorService e = Executors.newFixedThreadPool(2);
    static int N = 1000000;

    public static void main(String[] args) throws Exception {    
        for (int i = 0; i < 10; i++) {
            int length = (i == 0) ? 1 : i * 5;
            System.out.print(length + "\t");
            System.out.print(doTest(new LinkedBlockingQueue<Integer>(length), N) + "\t");
            System.out.print(doTest(new ArrayBlockingQueue<Integer>(length), N) + "\t");
            System.out.print(doTest(new SynchronousQueue<Integer>(), N));
            System.out.println();
        }

        e.shutdown();
    }

    private static long doTest(final BlockingQueue<Integer> q, final int n) throws Exception {
        long t = System.nanoTime();

        e.submit(new Runnable() {
            public void run() {
                for (int i = 0; i < n; i++)
                    try { q.put(i); } catch (InterruptedException ex) {}
            }
        });    

        Long r = e.submit(new Callable<Long>() {
            public Long call() {
                long sum = 0;
                for (int i = 0; i < n; i++)
                    try { sum += q.take(); } catch (InterruptedException ex) {}
                return sum;
            }
        }).get();
        t = System.nanoTime() - t;

        return (long)(1000000000.0 * N / t); // Throughput, items/sec
    }
}    

Et voici un résultat sur ma machine: