测量执行代码所用的时间

Question

假设我有以下要计时的for循环：

for(int i = 0; i < list.size() - 1; i++ ) {     
{
// call other methods, let's say call other 3-4 methods

}

因此，如果我想测量在for循环之前和之后使用内置Java运行该循环所需的时间，它是否也会测量在我调用的方法中花费的时间？

或者，如果我不调用其他方法，而只是将所有代码放在for循环中，这将比只调用其他方法花费更多的时间？

Answer 1

计时器只是计算它开始和结束之间的时间差。它不知道在开始和结束之间发生了什么。因此，如果您将所有代码转储到for循环中，或者直接调用这些方法而不是内联它们，这都无关紧要。

然而，这不会为您提供每个单独函数所需的时间。您可能希望查看Java profilers，以便以更系统的方式获得结果。

Answer 2

System.nanoTime()返回正在运行的Java Virtual Machine的高分辨率时间源的当前值，以纳秒为单位。

来自Java的文档：

此方法只能用于测量经过的时间，与系统或挂钟时间的任何其他概念无关。返回的值表示从某个固定但任意的起始时间开始的纳秒(可能是在将来，因此值可能是负数)。Java虚拟机实例中此方法的所有调用都使用相同的源；其他虚拟机实例可能使用不同的源。

使用System.nanoTime()值计算时间将计算执行该循环所需的全部时间。这将包括循环中方法的执行时间(如果它们在那里)。

但是，如果您在循环中启动具有自己的执行时间的线程，则从点1到点2所用的时间将只是启动线程所用的时间，而不是它们的执行时间。

我找到了一个很好的方法来理解这件事。只需编写一段简单的代码：

long t1 = System.nanoTime();
long t2 = System.nanoTime();
System.out.println((t2 - t1) / 1000000);

1. 将其放入调试器中，并查看未应用任何breakpoints.
2. Now时会发生什么情况在第2行应用断点，并在那里等待一段时间后再继续执行。

你可以看到不同之处。

Reference Link

Answer 3

这里是一个简单的例子，我将使用它来做一些基本的和不精确的测试。

我们首先需要一些基本的方法来方便地启动和打印时间

public class Main {

    static long start;

    static void startTest(){
        start = System.nanoTime();
    }

    static void stopTest(){
        System.out.format("%012.6f ms\n",(System.nanoTime() - start)/1000000.0);
        start = -1;
    }
}

单线程

让我们在一个空循环上运行一个测试：

startTest();
for(int i = 0; i < Integer.MAX_VALUE; ++i){}
stopTest();

这将等待循环结束，然后再调用stopTest()并打印所需的时间。

多线程

对于不同的线程，你需要等待它们结束，这很简单，并且可以通过多种方式避免。这里有一个：

startTest();
List<Callable<String>> list = new ArrayList();
for(int i=0;i<5;i++){
    list.add(new Callable() {
        public Object call() throws Exception {
            for(int i = 0; i < Integer.MAX_VALUE/5; ++i){}
            System.out.println("End of Thread");
            return null;
        }
    });
}
ExecutorService es = Executors.newCachedThreadPool();
try {

    es.invokeAll(list);
} catch (InterruptedException ex) {
    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
} finally {
    stopTest();
    es.shutdown();
}

有了这个Executors，我们可以同时调用所有的Callable，等待它们结束。