《Java 并发编程·性能诊断与事故》6.1 十万/百万虚拟线程实测

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;

/** 创建 N 个虚拟线程并让它们全部挂起，量创建成本与堆占用。 */
public final class VtScale {

    static final ThreadMXBean TMX = ManagementFactory.getThreadMXBean();
    static final MemoryMXBean MEM = ManagementFactory.getMemoryMXBean();
    static final AtomicLong TOUCHED = new AtomicLong();

    static long usedHeap() {
        return MEM.getHeapMemoryUsage().getUsed();
    }

    static long carriers() {
        return Thread.getAllStackTraces().keySet().stream()
                .map(Thread::getName)
                .filter(n -> n.startsWith("ForkJoinPool-1-worker"))
                .count();
    }

    public static void main(String[] args) throws Exception {
        int n = Integer.parseInt(args[0]);
        System.out.printf("maxHeap=%dMB 要创建=%d%n", Runtime.getRuntime().maxMemory() / (1 << 20), n);

        System.gc();
        long heap0 = usedHeap();
        long threads0 = TMX.getThreadCount();

        CountDownLatch hold = new CountDownLatch(1);
        CountDownLatch started = new CountDownLatch(n);
        Thread[] refs = new Thread[n];

        long t0 = System.nanoTime();
        for (int i = 0; i < n; i++) {
            final int id = i;
            refs[i] = Thread.ofVirtual().name("vt-" + id).start(() -> {
                TOUCHED.incrementAndGet();
                started.countDown();
                try {
                    hold.await();                 // 全部挂起，保持存活
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                TOUCHED.incrementAndGet();
            });
        }
        started.await();
        long createMs = (System.nanoTime() - t0) / 1_000_000L;

        long heap1 = usedHeap();
        System.out.printf("创建完成: %d 个, 耗时 %d ms%n", n, createMs);
        System.out.printf("堆: %dMB -> %dMB, 增量 %dMB, 每个约 %d 字节%n",
                heap0 / (1 << 20), heap1 / (1 << 20),
                (heap1 - heap0) / (1 << 20), (heap1 - heap0) / Math.max(1, n));
        System.out.printf("ThreadMXBean.getThreadCount(): %d -> %d%n", threads0, TMX.getThreadCount());
        System.out.println("载体线程数(按线程名统计): " + carriers());
        System.out.println("JAVA_PID=" + ProcessHandle.current().pid());

        Thread.sleep(20_000);                     // 保持存活，供外部 jcmd 观察
        long t1 = System.nanoTime();
        hold.countDown();
        for (Thread t : refs) t.join();
        System.out.printf("join 耗时 %d ms, 任务计数=%d%n",
                (System.nanoTime() - t1) / 1_000_000L, TOUCHED.get());
    }
}

garbage-first heap   total reserved 8388608K, committed 2887680K, used 922625K

jcmd <pid> Thread.print > /tmp/tp.txt
wc -l /tmp/tp.txt          # 208 行
grep -c 'vt-' /tmp/tp.txt  # 0

ThreadMXBean.getThreadCount(): 6 -> 17
ThreadMXBean.getTotalStartedThreadCount(): 6 -> 17

jcmd <pid> Thread.dump_to_file -format=plain /tmp/dump.txt

#27 "vt-0" virtual WAITING 2026-10-28T19:04:22.350861Z
    at java.base/java.lang.VirtualThread.park(VirtualThread.java:745)
    - parking to wait for <java.util.concurrent.CountDownLatch$Sync@2f54d2c8>
    at java.base/java.util.concurrent.locks.LockSupport.park(LockSupport.java:221)
    at java.base/java.util.concurrent.CountDownLatch.await(CountDownLatch.java:230)
    at VtScale.lambda$main$0(VtScale.java:49)

import jdk.management.VirtualThreadSchedulerMXBean;
import java.lang.management.ManagementFactory;

VirtualThreadSchedulerMXBean sched = ManagementFactory.getPlatformMXBean(
        VirtualThreadSchedulerMXBean.class);
System.out.printf("parallelism=%d poolSize=%d mounted=%d queued=%d%n",
        sched.getParallelism(), sched.getPoolSize(),
        sched.getMountedVirtualThreadCount(), sched.getQueuedVirtualThreadCount());

package com.plume.conc.ops;

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;

/**
 * 按实测的每线程字节数反推安全规模。
 * 不对线程数做任何硬编码，只做「已知条件 + 余量系数」的除法。
 */
public final class VtCapacity {

    private static final MemoryMXBean MEM = ManagementFactory.getMemoryMXBean();

    /** bytesPerThread 用 VtScale 实测，不要抄别人的 1 KB。 */
    public static int safeThreads(long bytesPerThread, double heapRatio) {
        long max = Runtime.getRuntime().maxMemory();
        long usable = (long) (max * heapRatio);
        return (int) Math.min(Integer.MAX_VALUE, usable / bytesPerThread);
    }

    /** 启动时先建 1 万个量一次，避免用理论值估算。 */
    public static long measureBytesPerThread() throws InterruptedException {
        int probe = 10_000;
        System.gc();
        long before = MEM.getHeapMemoryUsage().getUsed();
        Thread[] refs = new Thread[probe];
        java.util.concurrent.CountDownLatch hold = new java.util.concurrent.CountDownLatch(1);
        for (int i = 0; i < probe; i++) {
            refs[i] = Thread.ofVirtual().start(() -> {
                try {
                    hold.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        Thread.sleep(200);
        long after = MEM.getHeapMemoryUsage().getUsed();
        hold.countDown();
        for (Thread t : refs) {
            t.join();
        }
        return Math.max(1, (after - before) / probe);
    }
}

在飞线程数      = 50 000
每线程堆        = 933 B          (本机实测，按 1 KB 保守取)
堆占用          = 50 000 × 1 KB ≈ 49 MB
载体需求        = 核数 × (1 + W/C) = 10 × (1 + 5/3) ≈ 27   (5.2 的公式)
实际载体        = 10             (调度器默认 = availableProcessors)