java 测量java短时间运行线程执行时间
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/14664897/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Measure java short time running thread execution time
提问by Morro
I'm currently working on some sort of database benchmark application. Basically, what I'm trying to do is to simulate using threads a certain number of clients that all repeat the same operation (example: a read operation) against the database during a certain period of time.
During this time, I want, in each thread, to measure the average delay for getting an answer from the database.
我目前正在研究某种数据库基准测试应用程序。基本上，我想要做的是使用线程模拟一定数量的客户端，这些客户端都在特定时间段内对数据库重复相同的操作（例如：读取操作）。
在此期间，我想在每个线程中测量从数据库获取答案的平均延迟。
My first choice was to rely on ThreadMXBean's getThreadCpuTime() method (http://docs.oracle.com/javase/7/docs/api/java/lang/management/ThreadMXBean.html) but the point is that the operation is done too quickly to be measured (getThreadCpuTime() before the operation is equal to getThreadCpuTime() after the operation).
我的第一选择是依靠 ThreadMXBean 的 getThreadCpuTime() 方法（http://docs.oracle.com/javase/7/docs/api/java/lang/management/ThreadMXBean.html）但重点是操作完成太快无法测量（操作前的 getThreadCpuTime() 等于操作后的 getThreadCpuTime()）。
I made a little experiment to understand and illustrate the problem:
我做了一个小实验来理解和说明问题：
public class ExampleClass {
class LongRunningThread extends Thread {
private int n;
public LongRunningThread(int n) {
this.n = n;
}
public void run() {
ArrayList l = new ArrayList();
for (int i = 0; i < n; i++) {
l.add(new Object());
}
long time = ManagementFactory.getThreadMXBean().getThreadCpuTime(this.getId());
System.out.println("Long running thread " + this.getId() + " execution time: " + time);
}
}
class MyThread extends Thread {
int n;
public MyThread(int n) {
this.n = n;
}
public void run() {
ArrayList l = new ArrayList();
for (int i = 0; i < n; i++) {
l.add(new Object());
}
long time = ManagementFactory.getThreadMXBean().getThreadCpuTime(this.getId());
System.out.println("My thread " + this.getId() + " execution time: " + time);
}
}
public static void main(String [] args) {
System.out.println("Cpu time supported? " + ManagementFactory.getThreadMXBean().isThreadCpuTimeSupported());
System.out.println("Cpu time enabled? " + ManagementFactory.getThreadMXBean().isThreadCpuTimeEnabled());
for (int i = 1; i < 10; ++i) {
new LongRunningThread(i*1000000).start();
}
for (int i = 1; i < 10; ++i) {
new MyThread(i*100).start();
}
}
Output:
Cpu time supported? true
Cpu time enabled? true
My thread 18 execution time: 0
My thread 26 execution time: 0
My thread 20 execution time: 0
My thread 22 execution time: 0
My thread 24 execution time: 0
My thread 21 execution time: 0
My thread 25 execution time: 0
My thread 19 execution time: 0
My thread 23 execution time: 0
Long running thread 9 execution time: 15600100
Long running thread 10 execution time: 15600100
Long running thread 11 execution time: 46800300
Long running thread 12 execution time: 31200200
Long running thread 14 execution time: 78000500
Long running thread 13 execution time: 78000500
Long running thread 17 execution time: 124800800
Long running thread 15 execution time: 140400900
Long running thread 16 execution time: 109200700
I cannot get the execution time for all MyThreadinstances but no problem for LongRunningThreadinstances. Like I said, my hypothesis is that the operation done by the first threads happen too fast to be actually measured.
Is there any way to achieve what I'm trying to do? Is it possible to measure the execution time for such short time running threads?
我无法获得所有MyThread实例的执行时间，但实例没有问题LongRunningThread。就像我说的，我的假设是第一个线程完成的操作发生得太快而无法实际测量。有什么方法可以实现我想要做的事情吗？是否可以测量如此短时间运行的线程的执行时间？
Thanks in advance for you help :)
预先感谢您的帮助:)
回答by imrichardcole
Have you considerd this framework http://metrics.codahale.com/. It's very very good and comes with built in support for exposing metrics via JMX
你有没有考虑过这个框架http://metrics.codahale.com/。它非常好，并且内置支持通过 JMX 公开指标
回答by Gray
Is it possible to measure the execution time for such short time running threads?
是否可以测量如此短时间运行的线程的执行时间？
Without measuring wall-clock times with the nano-second clock, the answer may be no. For small loops, the measured CPU time may be smaller than the precision of the method. The javadocs for ThreadMXBean.getThreadCpuTime(...)say:
如果不使用纳秒时钟测量挂钟时间，答案可能是否定的。对于小循环，测得的 CPU 时间可能小于方法的精度。该对的javadocThreadMXBean.getThreadCpuTime(...)说：
Returns the total CPU time for a thread of the specified ID in nanoseconds. The returned value is of nanoseconds precision but not necessarily nanoseconds accuracy.
返回指定 ID 的线程的总 CPU 时间（以纳秒为单位）。返回值是纳秒精度，但不一定是纳秒精度。
One thing to consider would be to take the CPU time if it is > 0 and take the wall-clock time if it is == 0.
需要考虑的一件事是，如果 CPU 时间 > 0，则取 CPU 时间，如果它 = 0，则取挂钟时间。
回答by iMysak
as easier solution you can use next :
作为更简单的解决方案，您可以在接下来使用：
class MyThread extends Thread {
int n;
public MyThread(int n) {
this.n = n;
}
public void run() {
long startTime = System.nanoTime();
ArrayList l = new ArrayList(n);
for (int i = 0; i < n; i++) {
l.add(new Object());
}
long time = System.nanoTime() - startTime;
System.out.println("My thread " + this.getId() + " execution time: " + time + " ns");
}
}
if you don't need nanoseconds precision you can use System.currentTimeMillis()instead.
如果您不需要纳秒精度，则可以System.currentTimeMillis()改用。
