Question

我遇到的问题是我创建的Java算法，用于将纳秒CPU时间使用（通过JMX获得）转换为百分之百的百分比。该算法似乎给出了大于100％的数字，我认为这是由于多个可用的处理器，尽管代码应该排除这一点。该算法可以在下面看到。 cpuTimeDiffNS是以纳秒为单位的CPU时间量，而periodMS是采样周期。

public static final double getCPUPerc(long cpuTimeDiffNS, long periodMS) {
    if (periodMS == 0) return 0;
    double cpuTimeDiffMS = cpuTimeDiffNS / 1000000d;
    int procs = Runtime.getRuntime().availableProcessors();
    long availableTime = periodMS * procs;
    double perc = cpuTimeDiffMS / availableTime;
    return perc * 100d;
}

以下是数据采集的一些样本：

0
87.5
133.8288232
160.8231707
197.7896341
209.6036585
248.822774
274.3902439
267.9115854
271.3414634
277.1067759
283.1554878
272.1036585
279.4000734
283.9176829
283.5365854
275.9146341
282.4578033
278.9634146
261.0536937
254.6071775
286.662182
278.9634146
276.7245597
288.4908537
281.6933708
286.9664634
279.7822896
276.2957317
280.4878049
275.5335366
271.7557485
280.8689024
287.2689689
281.6933708
267.5097276
273.2469512
286.1735835
289.6341463
296.875
279.4000734
289.2530488
282.8400196
288.4908537
287.4266145
288.1097561
286.5853659
288.9554795
238.1207192
288.4908537
288.7063531
290.3963415
286.662182
277.4390244
290.4843444
281.6310976
271.7557485
272.8658537
283.2222358
250.7621951

编辑：根据要求，输入收集功能（你可以忽略这一点）：

// returns CPU time in NS for a thread group (recursively)
public static long getCPUTime(ThreadGroup tg) {
    synchronized (TGLOCK) {
        int size;
        do {
            size = tg.enumerate(tgThreads, true);
            if (size <= tgThreads.length) continue;
            tgThreads = new Thread[size];
        } while (size > tgThreads.length);

        long totalTime = 0;
        for (int i = 0; i < size; i++) {
            totalTime += getCPUTime(tgThreads[i]);
        }
        return totalTime;
    }
}

public static long getCPUTime(Thread t) {
    return threadMXBean.getThreadCpuTime(t.getId());
}

public static ThreadGroup getRootThreadGroup() {
    // Find the root thread group
    ThreadGroup root = Thread.currentThread().getThreadGroup().getParent();
    while (root.getParent() != null) {
        root = root.getParent();
    }
    return root;
}

和输入（再次，您可以忽略这一点）：

    simCPUTimeNS     = getCPUTime(kks.getSimThreadGroup());
    appsCPUTimeNS    = getCPUTime(kks.getAppThreadGroup());
    lwjns3CPUTimeNS  = getCPUTime(kks.getKKSThreadGroup());
    simCoreCPUTimeNS = getCPUTime(kks.getSimThread());
    totalCPUTimeNS   = getCPUTime(getRootThreadGroup());

    simCPUTimeNSDiff  = simCPUTimeNS - lastSimCPUTimeNS;
    appsCPUTimeNSDiff = appsCPUTimeNS - lastAppsCPUTimeNS;
    lwjns3CPUTimeNSDiff = lwjns3CPUTimeNS - lastLwjns3CPUTimeNS;
    simCoreCPUTimeNSDiff = simCoreCPUTimeNS - lastSimCoreCPUTimeNS;
    totalCPUTimeNSDiff = totalCPUTimeNS - lastTotalCPUTimeNS;

    lastSimCPUTimeNS     = simCPUTimeNS;
    lastAppsCPUTimeNS    = appsCPUTimeNS;
    lastLwjns3CPUTimeNS  = lwjns3CPUTimeNS;
    lastSimCoreCPUTimeNS = simCoreCPUTimeNS;
    lastTotalCPUTimeNS   = totalCPUTimeNS;

    simCPUPerc     = getCPUPerc(simCPUTimeNSDiff, currDiffMS);
    appsCPUPerc    = getCPUPerc(appsCPUTimeNSDiff, currDiffMS);
    lwjns3CPUPerc  = getCPUPerc(lwjns3CPUTimeNSDiff, currDiffMS);
    simCoreCPUPerc = getCPUPerc(simCoreCPUTimeNSDiff, currDiffMS);
    totalCPUPerc   = getCPUPerc(totalCPUTimeNSDiff, currDiffMS);

为任何帮助干杯，我确定答案很明显;）
克里斯

Answer 1

因此，我们使用类似的代码来计算平均负载，并且（事实证明）它有一个可能在您的代码中的错误。我们使用getAllThreadIds()但它只返回“活动”线程，enumerate也会这样做。如果你的任何线程停止，那么总的cpu时间可能会下降。我不明白这会导致价值超过100％。

对您的代码发表评论：

为什么synchronized (TGLOCK)行？这是为了同步ThreadGroup对象吗？
if (size <= tgThreads.length) continue;应该是break;。没有必要进行双重测试。
enumerate返回放入数组中的线程数。这总是<= tg.length所以如果我正确地准备它，阵列将永远不会增长。如果确实返回了更大的尺寸，那么你就会得到NPE，因为你在检查之前有tgThreads = new Thread[size];这是永远不会成真的。

您是否有理由使用ThreadGroup？我们使用以下不需要递归或其他任何内容：

for (long id : threadMxBean.getAllThreadIds()) {
    long cpuTime = threadMxBean.getThreadCpuTime(id);

希望这至少有所帮助。

Answer 2

我正在运行一个时间膨胀的JVM（5倍减速），看起来我忘了在os_windows.cpp（os::thread_cpu_time）中调整C ++ JVM代码的一部分时进行调整。哎呀。它使用timeGetTime()，一个Windows时间函数。那就解释了。

CPU时间百分比算法问题

2 个答案: