性能测试 java,Java性能测试

I want to do some timing tests on a Java application. This is what I am currently doing:

long startTime = System.currentTimeMillis();

doSomething();

long finishTime = System.currentTimeMillis();

System.out.println("That took: " + (finishTime - startTime) + " ms");

Is there anything "wrong" with performance testing like this? What is a better way?

解决方案

The one flaw in that approach is that the "real" time doSomething() takes to execute can vary wildly depending on what other programs are running on the system and what its load is. This makes the performance measurement somewhat imprecise.

One more accurate way of tracking the time it takes to execute code, assuming the code is single-threaded, is to look at the CPU time consumed by the thread during the call. You can do this with the JMX classes; in particular, with ThreadMXBean. You can retrieve an instance of ThreadMXBean from java.lang.management.ManagementFactory, and, if your platform supports it (most do), use the getCurrentThreadCpuTime method in place of System.currentTimeMillis to do a similar test. Bear in mind that getCurrentThreadCpuTime reports time in nanoseconds, not milliseconds.

Here's a sample (Scala) method that could be used to perform a measurement:

def measureCpuTime(f: => Unit): java.time.Duration = {

import java.lang.management.ManagementFactory.getThreadMXBean

if (!getThreadMXBean.isThreadCpuTimeSupported)

throw new UnsupportedOperationException(

"JVM does not support measuring thread CPU-time")

var finalCpuTime: Option[Long] = None

val thread = new Thread {

override def run(): Unit = {

f

finalCpuTime = Some(getThreadMXBean.getThreadCpuTime(

Thread.currentThread.getId))

}

}

thread.start()

while (finalCpuTime.isEmpty && thread.isAlive) {

Thread.sleep(100)

}

java.time.Duration.ofNanos(finalCpuTime.getOrElse {

throw new Exception("Operation never returned, and the thread is dead " +

"(perhaps an unhandled exception occurred)")

})

}

(Feel free to translate the above to Java!)

This strategy isn't perfect, but it's less subject to variations in system load.