Java Async Profiler Flame Graph

Question

В приведенном ниже сценарии является ли асинхронный профилировщик Java подходящим инструментом для определения времени, потраченного при сравнении производительности ArrayBlockingQueue и LinkedBlockingQueue?

На моей машине общее время выполнения ABQ всегда на 25% быстрее, чем LBQ, при совместном использовании 50 М записей между потребителем и производителем. Графики Flame для обоих «почти» одинаковы, за исключением того, что LBQ показывает только несколько образцов из кода размещения объектов JVM, но это не оправдывает увеличение на 25%. Как и ожидалось, распределение TLAB в LBQ намного выше.

Мне было интересно, как я могу увидеть, какая деятельность (будь то код или оборудование) занимает время?

Бегун:

      import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Runner {

    public static void main(String[] args) throws InterruptedException {


        int size = 50_000_000;
        BlockingQueue<Long> queue = new LinkedBlockingQueue<>(size);

        Producer producer = new Producer(queue, size);
        Thread t = new Thread(producer);
        t.setName("ProducerItIs");

        Consumer consumer = new Consumer(queue, size);
        Thread t2 = new Thread(consumer);
        t2.setName("ConsumerItIs");


        t.start();
        t2.start();

        Thread.sleep(8000);
        System.out.println("done");
        queue.forEach(System.out::println);
        System.out.println(queue.size());
    }
}

Режиссер:

      import java.util.Queue;
import java.util.Random;
import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

    public Producer(BlockingQueue<Long> blockingQueue, int size) {
        this.queue = blockingQueue;
        this.size = size;

    }

    private final BlockingQueue<Long> queue;
    private final int size;

    public void run() {

        System.out.println("Started to produce...");
        long nanos = System.nanoTime();
        Long ii = (long) new Random().nextInt();

        for (int j = 0; j < size; j++) {
                queue.add(ii);
        }
        System.out.println("producer Time taken :" + ((System.nanoTime() - nanos) / 1e6));
    }
}

Потребитель:

      import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {

    private final BlockingQueue<Long> blockingQueue;
    private final int size;


    private Long value;

    public Consumer(BlockingQueue<Long> blockingQueue, int size) {
        this.blockingQueue = blockingQueue;
        this.size = size;
    }

    public void run() {
        long nanos = System.nanoTime();

        System.out.println("Starting to consume...");
        int i = 1;
        try {
            while (true) {
                value = blockingQueue.take();
                i++;

                if (i >= size) {
                    break;
                }

            }
            System.out.println("Consumer Time taken :" + ((System.nanoTime() - nanos)/1e6));
        } catch (Exception exp) {
            System.out.println(exp);
        }
    }
    public long getValue() {
        return value;
    }
}

С ArrayBlockingQueue:

С LinkedListBlockedQueue: черная стрелка, показывающая образцы, захваченные для распределения