Измерение времени, затраченное на выполнение кода

Question

Допустим, я следующий цикл, который я хочу время:

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

} 

Итак, если я хочу, чтобы определить, насколько много времени, что для цикла требуется, чтобы работать с ин построил Java long time = System.nanoTime(); до и после цикла for, будет ли он также измерять время, потраченное внутри методов, которые я вызываю?

Или если я не вызываю другие методы и просто помещаю весь код в цикл for for, это займет гораздо больше времени, чем если бы я просто вызывал другие методы?

Answer 1

Таймер просто подсчитывает разницу между временем начала и конца. Он не знает, что произошло между началом и концом. Поэтому неважно, вы сбросите весь свой код внутри цикла for или вызовите эти методы напрямую, а не вставляете их.

Однако это не даст вам время, затрачиваемое каждой отдельной функцией. Вы можете посмотреть на Java profilers, чтобы получить результаты более систематическим образом.

Answer 2

System.nanoTime() возвращает текущее значение используемого источника времени с высокой разрешающей способностью Java Virtual Machine в наносекундах.

Из Документация Явы:

Этот метод может быть использован только для измерения затраченного времени и не связан с любым другим понятием системы или на стене часов времени. Возвращаемое значение представляет собой наносекунды, поскольку некоторое фиксированное, но произвольное происхождение (возможно, в будущем, поэтому значения могут быть отрицательными). То же самое начало используется всеми вызовами этого метода в экземпляре виртуальной машины Java ; другие экземпляры виртуальной машины, вероятно, будут иметь значение .

Расчет времени с использованием значений System.nanoTime() рассчитал бы полное время, затраченное на выполнение этого цикла. Это будет включать время выполнения методов внутри цикла (если они есть).

Однако, если происходит запуск потоков внутри цикла, у которых есть собственное время выполнения, время, прошедшее от точки 1 до точки 2, будет временем, затрачиваемым на запуск потоков, а не на время их выполнения.

---

Я нашел хороший способ понять эту вещь. Просто написать простой код:

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

1. Вытащите это в отладчик и посмотреть, что происходит, когда вы не применять какие-либо контрольные точки.

2. Теперь примените точку останова в строке # 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; 
    } 
} 

Single Thread

Позволяет запустить тест на пустом цикле:

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 в то же время ожидания для них до конца.