Java время в наносекундах

Как замерить время выполнения

Зачастую требуется узнать, сколько времени выполняется тот или иной код. Иногда требуется замерить время выполнения метода или какой-то задачи. В данной статье мы расскажем вам принципы замера времени в Java и покажем лучшие практики для конкретных задач.

Замер времени с помощью currentTimeMills()

Это довольно простой способ измерить время. Метод System.currentTimeMillis() вернёт вам текущее время в миллисекундах. Его потребуется вызвать до выполнения нужной задачи и после, а затем вычислить разницу. В итоге мы узнаем время выполнения в миллисекундах:

long start = System.currentTimeMillis(); // выполнение какой-то логики Thread.sleep(1000); long finish = System.currentTimeMillis(); long elapsed = finish - start; System.out.println("Прошло времени, мс: " + elapsed);

При работе с данным методом следует учитывать его специфику: System.currentTimeMillis() показывает текущее время, основываясь на системных часах и может выдавать некорректный результат.

Замер времени с помощью nanoTime()

Ещё один метод для получения текущего времени это System.nanoTime(). Как следует из названия, этот метод возвращает время с точностью до нансекунд. Также работа этого метода не зависит от системных часов.

Он используется аналогично:

long start = System.nanoTime(); // выполнение какой-то логики Thread.sleep(1000); long finish = System.nanoTime(); long elapsed = finish - start; System.out.println("Прошло времени, нс: " + elapsed);

Для получения значения в миллисекундах результат можно разделить на 1000:

System.out.println("Прошло времени, мс: " + elapsed / 1000000);

Важно: Хотя метод nanoTime() может возвращать время в наносекундах, он не гарантирует, что значения между его вызовами будут обновляться с точностью до наносекунд.

Но всё же это более приемлемый вариант, чем System.currentTimeMillis().

Замер времени с помощью Instant и Duration

В Java 8 добавили новый java.time API. В частности, ля измерения времени подойдут два новых класса – Instant и Duration. Оба эти класса иммутабельны.

Instant обозначает момент времени с начала эпохи Unix (1970-01-01T00:00:00Z). Для создания момента мы используем метод Instant.now(). После того, как мы создали два момент, вычислим разницу в миллисекундах:

Instant start = Instant.now(); // выполнение какой-то логики Thread.sleep(1000); Instant finish = Instant.now(); long elapsed = Duration.between(start, finish).toMillis(); System.out.println("Прошло времени, мс: " + elapsed);

Рекомендуется использовать именно этот подход в Java 8 и выше.

Замер времени выполнения с помощью StopWatch

StopWatch – это класс из библиотеки Apache Commons Lang. Он работает как секундомер. Для его использования сначала требуется подключить библиотеку к проекту:

 org.apache.commons commons-lang3 3.9 

Теперь создадим экземпляр StopWatch. Затем начнём отсчёт с помощью метода start() и окончим отсчёт с помощью метода stop():

public static void stopWatch() throws InterruptedException < StopWatch stopWatch = new StopWatch(); stopWatch.start(); // выполнение какой-то логики Thread.sleep(1000); stopWatch.stop(); System.out.println("Прошло времени, мс: " + stopWatch.getTime()); >

StopWatch удобно использовать тогда, когда в проекте уже подключена данная библиотека.

Исходный код

package ru.javalessons.time; import org.apache.commons.lang3.time.StopWatch; import java.time.Duration; import java.time.Instant; public class MeasureElapsedTime < public static void main(String[] args) throws InterruptedException < currentTimeMillis(); nanoTime(); instant(); stopWatch(); >public static void currentTimeMillis() throws InterruptedException < long start = System.currentTimeMillis(); // выполнение какой-то логики Thread.sleep(1000); long finish = System.currentTimeMillis(); long elapsed = finish - start; System.out.println("Прошло времени, мс: " + elapsed); >public static void nanoTime() throws InterruptedException < long start = System.nanoTime(); // выполнение какой-то логики Thread.sleep(1000); long finish = System.nanoTime(); long elapsed = finish - start; System.out.println("Прошло времени, нс: " + elapsed); >public static void instant() throws InterruptedException < Instant start = Instant.now(); // выполнение какой-то логики Thread.sleep(1000); Instant finish = Instant.now(); long elapsed = Duration.between(start, finish).toMillis(); System.out.println("Прошло времени, мс: " + elapsed); >public static void stopWatch() throws InterruptedException < StopWatch stopWatch = new StopWatch(); stopWatch.start(); // выполнение какой-то логики Thread.sleep(1000); stopWatch.stop(); System.out.println("Прошло времени, мс: " + stopWatch.getTime()); >>

Заключение

В данной статье мы разобрали простые методы замера времени выполнения в Java. Для простых замеров можно использовать все вышеперечисленные методы, кроме currentTimeMillis (из-за того, что он зависит от системных часов).

Источник

How to get NanoSeconds in current Date time in Java

Returns the current value of the running Java Virtual Machine’s high-resolution time source, in nanoseconds.
This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents nanoseconds since some fixed but arbitrary origin time (perhaps in the future, so values may be negative). The same origin is used by all invocations of this method in an instance of a Java virtual machine; other virtual machine instances are likely to use a different origin.

This method provides nanosecond precision, but not necessarily nanosecond resolution (that is, how frequently the value changes) – no guarantees are made except that the resolution is at least as good as that of currentTimeMillis().

Differences in successive calls that span greater than approximately 292 years (263 nanoseconds) will not correctly compute elapsed time due to numerical overflow.

The values returned by this method become meaningful only when the difference between two such values, obtained within the same instance of a Java virtual machine, is computed.

For example, to measure how long some code takes to execute:

long startTime = System.nanoTime();
// … the code being measured …
long estimatedTime = System.nanoTime() – startTime;
To compare two nanoTime values

Returns:

Related Posts:

• How to convert epoch time to date in java
• converting java.time.localdatetime to java.util.date
• getting milliseconds from localDatetime in java 8
• Get system current date time in java
• Java convert seconds to days hours minutes
• Java get current date without time using LocalDate…
• Java get current date and time based on system date
• How to get the Current time in Milliseconds Java…
• Java convert hh mm ss to time | Java 8 LocalTime.of
• How to get Month Year Week using OffsetDateTime Object
• How to get Date without Time in Java
• How To Get System time using LocalDateTime java 8
• How to Convert java.util.Date to java.sql.Date
• How to Date Formatting In Java With Time Zone
• formatting date using new date time api
• java.net.URI() uri in java Code With Examples
• SimpleDateformat in java To Display Date in…
• How To Compare Two Dates in java using java 8 LocalDateTime
• How to Calculate Age from Date of birth Java
• How to get Year Month Date from Calendar Object in Java
• Java program to convert java.util.Date to…
• How to convert String to Date in Java in yyyy-mm-dd format
• Java subtract dates from given date
• File.lastModified() to Date Java Code With Examples
• Java date add days to given date

Источник

Измерение прошедшего времени в Java

Мы рассмотрим стандартные классы Java и внешние пакеты, которые предоставляют функции для измерения затраченного времени.

2. Простые измерения

2.1. currentTimeMillis()с

Когда мы сталкиваемся с требованием измерить прошедшее время в Java, мы можем попытаться сделать это следующим образом:

long start = System.currentTimeMillis(); // . long finish = System.currentTimeMillis(); long timeElapsed = finish - start;

Если мы посмотрим на код, это имеет смысл. Мы получаем метку времени в начале и получаем другую метку времени, когда код закончен. Прошедшее время — это разница между этими двумя значениями.

Однако время на настенных часахthe result may and will be inaccurate as System.currentTimeMillis() measures wall-clock time. может измениться по многим причинам, например, изменение системного времени может повлиять на результаты, или дополнительная секунда нарушит результат.

2.2. nanoTime()с

Другой метод в классеjava.lang.System —nanoTime(). Если мы посмотрим наJava documentation, мы найдем следующее утверждение:

«Этот метод может использоваться только для измерения прошедшего времени и не связан ни с каким другим понятием системного времени или времени настенных часов».

long start = System.nanoTime(); // . long finish = System.nanoTime(); long timeElapsed = finish - start;

Код в основном такой же, как и раньше. Единственное отличие — это метод, используемый для получения меток времени —nanoTime() вместоcurrentTimeMillis().

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

Например, чтобы преобразовать в миллисекунды, мы должны разделить результат в наносекундах на 1.000.000.

Другая ловушка сnanoTime() заключается в том, чтоeven though it provides nanosecond precision, it doesn’t guarantee nanosecond resolution (т.е. как часто значение обновляется).

Однако это гарантирует, что разрешение будет не ниже, чем уcurrentTimeMillis().

3. Java 8

Если мы используем Java 8, мы можем попробовать новые классыjava.time.Instant иjava.time.Duration. Оба являются неизменяемыми, поточно-ориентированными и используют собственную шкалу времени,Java Time-Scale,, как и все классы в новом APIjava.time.

3.1. Шкала времени Java

Традиционный способ измерения времени — это деление дня на 24 часа по 60 минут по 60 секунд, что дает 86 400 секунд в день. Однако солнечные дни не всегда одинаково длинны.

Шкала времени UTC фактически позволяет дню иметь 86,399 или 86,401 секунд СИ. Секунда СИ является научной «Стандартной международной секундой» и определяется периодами излучения атома цезия 133). Это необходимо для того, чтобы день соответствовал Солнцу.

The Java Time-Scale divides each calendar day into exactly 86.400 subdivisions, known as seconds. Там нет високосных секунд.

3.2. Instant Класс

КлассInstant представляет момент на временной шкале. По сути, это числовая метка времени со стандартной эпохи Java1970-01-01T00:00:00Z.

Чтобы получить текущую метку времени, мы можем использовать статический методInstant.now(). Этот метод позволяет передать необязательный параметрClock. Если опущен, он использует системные часы в часовом поясе по умолчанию.

We can store start and finish times in two variables, as in previous examples. Затем мы можем вычислить время, прошедшее между обоими моментами.

Мы можем дополнительно использовать классDuration и его методbetween(), чтобы получить продолжительность между двумя объектамиInstant. Наконец, нам нужно преобразоватьDuration в миллисекунды:

Instant start = Instant.now(); // CODE HERE Instant finish = Instant.now(); long timeElapsed = Duration.between(start, finish).toMillis();

4. StopWatchс

Переходя к библиотекам, Apache Commons Lang предоставляет классStopWatch, который можно использовать для измерения прошедшего времени.

4.1. Maven Dependency

Мы можем получить последнюю версию, обновив pom.xml:

 org.apache.commons commons-lang3 3.7 

Последнюю версию зависимости можно проверитьhere.

4.2. Измерение прошедшего времени сStopWatchс

Прежде всего, нам нужно получить экземпляр класса, а затем мы можем просто измерить прошедшее время:

StopWatch watch = new StopWatch(); watch.start();

Когда у нас запущены часы, мы можем выполнить код, который хотим протестировать, а затем, в конце, мы просто вызываем методstop(). Наконец, чтобы получить фактический результат, мы вызываемgetTime():

watch.stop(); System.out.println("Time Elapsed: " + watch.getTime()); // Prints: Time Elapsed: 2501

StopWatch has a few additional helper methods that we can use in order to pause or resume our measurement. Это может быть полезно, если нам нужно сделать наш тест более сложным.

Наконец, отметим, что класс не является потокобезопасным.

5. Заключение

Есть много способов измерить время в Java. Мы рассмотрели очень «традиционный» (и неточный) способ, используяcurrentTimeMillis(). Кроме того, мы проверилиStopWatch Apache Common и рассмотрели новые классы, доступные в Java 8.

В целом, для простых и правильных измерений прошедшего времени достаточно методаnanoTime(). Он также короче, чемcurrentTimeMillis().

Отметим, однако, что для правильного тестирования производительности вместо ручного измерения времени мы можем использовать такую ​​платформу, как Java Microbenchmark Harness (JMH). Эта тема выходит за рамки данной статьи, но мы исследовалиit here.

Наконец, как всегда, код, использованный во время обсуждения, можно найтиover on GitHub.

Источник