jvm condition and locksupport which is faster?

An experimental example of synchronous call is made. Each thread task waits for a task callback with its own value of + 1. The performance difference between condition and locksupport is compared. The result is unexpected. The two times are the same, but the difference on the flame diagram is very big. Does it mean that the JVM has not optimized locksupport

enter image description here public class LockerTest {

static int max = 100000;
static boolean usePark = true;

static Map<Long, Long> msg = new ConcurrentHashMap<>();
static ExecutorService producer = Executors.newFixedThreadPool(4);
static ExecutorService consumer = Executors.newFixedThreadPool(16);
static AtomicLong record = new AtomicLong(0);
static CountDownLatch latch = new CountDownLatch(max);

static ReentrantLock lock = new ReentrantLock();
static Condition cond = lock.newCondition();

static Map<Long, Thread> parkMap = new ConcurrentHashMap<>();

static AtomicLong cN = new AtomicLong(0);

public static void main(String[] args) throws InterruptedException {
    long start = System.currentTimeMillis();
    for (int num = 0; num < max; num++) {
        consumer.execute(() -> {
            long id = record.incrementAndGet();
            msg.put(id, -1L);
            call(id);

            if (usePark) {
                Thread thread = Thread.currentThread();
                parkMap.put(id, thread);
                while (msg.get(id) == -1) {
                    cN.incrementAndGet();
                    LockSupport.park(thread);
                }
            } else {
                lock.lock();
                try {
                    while (msg.get(id) == -1) {
                        cN.incrementAndGet();
                        cond.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
            latch.countDown();
        });
    }

    latch.await();
    consumer.shutdown();
    producer.shutdown();

    System.out.printf("park %s suc %s cost %s cn %s"
            , usePark
            , msg.entrySet().stream().noneMatch(entry -> entry.getKey() + 1 != entry.getValue())
            , System.currentTimeMillis() - start
            , cN.get()
    );
}

private static void call(long id) {
    producer.execute(() -> {
        try {
            Thread.sleep((id * 13) % 100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (usePark) {
            msg.put(id, id + 1);
            LockSupport.unpark(parkMap.remove(id));
        } else {
            lock.lock();
            try {
                msg.put(id, id + 1);
                cond.signalAll();
            } finally {
                lock.unlock();
            }
        }
    });
}

}