Большинство поисковых запросов в Google возвращают результаты для таймеров, которые планируют потоки и задачи, что мне не нужно.
JAMon API — это бесплатный, простой, высокопроизводительный, потокобезопасный Java API, который позволяет разработчикам легко контролировать производительность и масштабируемость производственных приложений. JAMon отслеживает совпадения, время выполнения (общее, среднее, минимальное, максимальное, стандартное отклонение) и многое другое. http://jamonapi.sourceforge.net/ скачать : http://sourceforge.net/project/showfiles.php?group_id=96550 — Mike Pone
Вы также можете посмотреть на Секундомер Apache Commons Lang класс. Простой, но полезный служебный класс. — user101561
Да, секундомер отлично подходит для этого. — Shubham Pandey
30 ответы
Всегда есть старомодный способ:
long startTime = System.nanoTime(); methodToTime(); long endTime = System.nanoTime(); long duration = (endTime — startTime); //divide by 1000000 to get milliseconds.
Создан 08 июля ’16, 22:07
Java. Работа с датой и временем.
на самом деле, это «по-новому», потому что вы использовали nanoTime, который не был добавлен до java5 — Джон Гарднер
Это (или использование System.currentTimeMillis ()) похоже на то, как это обычно делается в Java . что я все равно видел. Меня все еще слегка удивляет, что нет удобного встроенного класса, такого как Timer t = new Timer (); Строка s = t.getElapsed (формат); так далее. — Огре Псалом 33
Конечно, всегда важно помнить о подводных камнях микротестирования, таких как оптимизация компилятора / JVM, которая может исказить результат = 😎 — Юваль
В блоке finally нет необходимости, поскольку endTime не будет использоваться при возникновении исключения. — Питер Лоури
Я согласен с простым ответом. Работает для меня.
long startTime = System.currentTimeMillis(); doReallyLongThing(); long endTime = System.currentTimeMillis(); System.out.println(«That took » + (endTime — startTime) + » milliseconds»);
Работает неплохо. Разрешение, очевидно, составляет всего миллисекунды, вы можете добиться большего с помощью System.nanoTime (). Для обоих есть некоторые ограничения (срезы расписания операционной системы и т. Д.), Но это работает довольно хорошо.
Среднее значение за пару прогонов (чем больше, тем лучше), и вы получите неплохое представление.
ответ дан 07 окт ’08, 21:10
На самом деле System.currentTimeMillis () точен только выше 15 мс. При действительно низких значениях этому нельзя доверять. Решением для этого (как уже упоминалось) является System.nanoTime (); — Стив г
Хорошо, я собирался принять это как официальный ответ, пока не прочитал комментарий Стива Дж. Отличный лакомый кусочек, Стив! — Огре Псалом 33
nanoTime () не гарантирует точности лучше, чем currentTimeMillis, но многие реализации JVM действительно имеют лучшую точность с nanoTime. — Джеймс Шек
Одно небольшое преимущество currentTimeMillis заключается в том, что это фактическая временная метка, которая также может использоваться для регистрации времени начала / окончания, в то время как nanoTime «может использоваться только для измерения прошедшего времени и не имеет отношения к какому-либо другому понятию системного времени или времени настенных часов». — Брэд Паркс
Урок по Java 48: Даты, календари и время.
Давайте, ребята! Никто не упомянул Гуава способ сделать это (что, возможно, потрясающе):
import com.google.common.base.Stopwatch; Stopwatch timer = Stopwatch.createStarted(); //method invocation LOG.info(«Method took: » + timer.stop());
Приятно то, что Stopwatch.toString () хорошо справляется с выбором единиц времени для измерения. Т.е. если значение маленькое, оно выдаст 38 нс, если оно длинное, то 5 м 3 с.
Stopwatch timer = Stopwatch.createUnstarted(); for (. ) < timer.start(); methodToTrackTimeFor(); timer.stop(); methodNotToTrackTimeFor(); >LOG.info(«Method took: » + timer);
Примечание. Google Guava требует Java 1.6+.
К сожалению, секундомер Guava не является потокобезопасным. я усвоил это на собственном горьком опыте. — Декстер Легаспи
Параллельное использование секундомера приведет к тому, что вы позвоните start() несколько раз подряд (то же самое для stop() ). — Мингвэй Самуэль
Instant start = Instant.now(); Thread.sleep(5000); Instant end = Instant.now(); System.out.println(Duration.between(start, end));
PT5S
Спасибо, как я могу вывести результат, не имея ПТ впереди? — java123999
Проблема с методом заключается в том, что Instant не нарушает точность в миллисекундах и наносекундах. Ссылка: stackoverflow.com/questions/20689055/… — прашанцункари
Собрал все возможные пути в одно место.
Date startDate = Calendar.getInstance().getTime(); long d_StartTime = new Date().getTime(); Thread.sleep(1000 * 4); Date endDate = Calendar.getInstance().getTime(); long d_endTime = new Date().getTime(); System.out.format(«StartDate : %s, EndDate : %s n», startDate, endDate); System.out.format(«Milli = %s, ( D_Start : %s, D_End : %s ) n», (d_endTime — d_StartTime),d_StartTime, d_endTime);
long startTime = System.currentTimeMillis(); Thread.sleep(1000 * 4); long endTime = System.currentTimeMillis(); long duration = (endTime — startTime); System.out.format(«Milli = %s, ( S_Start : %s, S_End : %s ) n», duration, startTime, endTime ); System.out.println(«Human-Readable format : «+millisToShortDHMS( duration ) );
Человек читаемый Формат
public static String millisToShortDHMS(long duration) < String res = «»; // java.util.concurrent.TimeUnit; long days = TimeUnit.MILLISECONDS.toDays(duration); long hours = TimeUnit.MILLISECONDS.toHours(duration) — TimeUnit.DAYS.toHours(TimeUnit.MILLISECONDS.toDays(duration)); long minutes = TimeUnit.MILLISECONDS.toMinutes(duration) — TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(duration)); long seconds = TimeUnit.MILLISECONDS.toSeconds(duration) — TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(duration)); long millis = TimeUnit.MILLISECONDS.toMillis(duration) — TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(duration)); if (days == 0) res = String.format(«%02d:%02d:%02d.%04d», hours, minutes, seconds, millis); else res = String.format(«%dd %02d:%02d:%02d.%04d», days, hours, minutes, seconds, millis); return res; >
Гуава: Google Секундомер JAR- «Секундомер предназначен для измерения прошедшего времени в наносекундах.
com.google.common.base.Stopwatch g_SW = Stopwatch.createUnstarted(); g_SW.start(); Thread.sleep(1000 * 4); g_SW.stop(); System.out.println(«Google StopWatch : «+g_SW);
Apache Commons Ланг JAR- « Секундомер предоставляет удобный API для таймингов.
org.apache.commons.lang3.time.StopWatch sw = new StopWatch(); sw.start(); Thread.sleep(1000 * 4); sw.stop(); System.out.println(«Apache StopWatch : «+ millisToShortDHMS(sw.getTime()) );
ЙОДА-ВРЕМЯ
public static void jodaTime() throws InterruptedException, ParseException < java.text.SimpleDateFormat ms_SDF = new SimpleDateFormat(«yyyy/MM/dd HH:mm:ss.SSS»); String start = ms_SDF.format( new Date() ); // java.util.Date Thread.sleep(10000); String end = ms_SDF.format( new Date() ); System.out.println(«Start:»+start+»t Stop:»+end); Date date_1 = ms_SDF.parse(start); Date date_2 = ms_SDF.parse(end); Interval interval = new org.joda.time.Interval( date_1.getTime(), date_2.getTime() ); Period period = interval.toPeriod(); //org.joda.time.Period System.out.format(«%dY/%dM/%dD, %02d:%02d:%02d.%04d n», period.getYears(), period.getMonths(), period.getDays(), period.getHours(), period.getMinutes(), period.getSeconds(), period.getMillis()); >
API даты и времени Java из Java 8 «А Длительность объект представляет собой промежуток времени между двумя Мгновенное объекты.
Instant start = java.time.Instant.now(); Thread.sleep(1000); Instant end = java.time.Instant.now(); Duration between = java.time.Duration.between(start, end); System.out.println( between ); // PT1.001S System.out.format(«%dD, %02d:%02d:%02d.%04d n», between.toDays(), between.toHours(), between.toMinutes(), between.getSeconds(), between.toMillis()); // 0D, 00:00:01.1001
Spring Framework обеспечивает Секундомер служебный класс для измерения прошедшего времени в Java.
StopWatch sw = new org.springframework.util.StopWatch(); sw.start(«Method-1»); // Start a named task Thread.sleep(500); sw.stop(); sw.start(«Method-2»); Thread.sleep(300); sw.stop(); sw.start(«Method-3»); Thread.sleep(200); sw.stop(); System.out.println(«Total time in milliseconds for all tasks :n»+sw.getTotalTimeMillis()); System.out.println(«Table describing all tasks performed :n»+sw.prettyPrint()); System.out.format(«Time taken by the last task : [%s]:[%d]», sw.getLastTaskName(),sw.getLastTaskTimeMillis()); System.out.println(«n Array of the data for tasks performed « Task Name: Time Taken»); TaskInfo[] listofTasks = sw.getTaskInfo(); for (TaskInfo task : listofTasks)
Total time in milliseconds for all tasks : 999 Table describing all tasks performed : StopWatch »: running time (millis) = 999 —————————————— ms % Task name —————————————— 00500 050% Method-1 00299 030% Method-2 00200 020% Method-3 Time taken by the last task : [Method-3]:[200] Array of the data for tasks performed « Task Name: Time Taken [Method-1]:[500] [Method-2]:[299] [Method-3]:[200]
Источник: stackovergo.com
Время выполнения измерения в Java – пример Spring StopWatch
Есть два способа измерить истекшее время выполнения в Java , используя System.currentTimeinMillis () или System.nanoTime (). Эти два метода могут использоваться для измерения прошедшего времени или времени выполнения между двумя вызовами метода или событием в Java. Вычисление истекшего времени – одна из первых вещей, которую Java-программист делает, чтобы узнать, сколько секунд или миллисекунд занимает выполнение метода или сколько времени занимает конкретный блок кода. Большинство программистов на Java знакомы с System.currentTimeInMillis (), которая существует с самого начала, в то время как в Java 1.5 представлена новая версия более точной утилиты измерения времени System.nanoTime, а также несколько новых функций в языке, таких как Generics , типы Enum , auto бокс и переменные аргументы или переменные . Вы можете использовать любой из них для измерения времени выполнения метода в Java. Хотя лучше использовать System.nanoTime () для более точного измерения временных интервалов.
В этом руководстве по Java-программированию мы увидим простую Java-программу для измерения времени выполнения с помощью System.nanoTime () и служебного класса StopWatch фреймворка Spring. Эта статья является продолжением моего поста, посвященного фундаментальным концепциям Java, таким как « Как сравнивать String в Java» , « Как правильно писать метод equals в Java» и « 4 способа зацикливания HashMap в Java» . Если вы еще не прочитали их, вы можете найти их полезными.
Пример программы Java для измерения времени выполнения в Java
Вот пример кода для измерения прошедшего времени между двумя кодовыми блоками с использованием System.nanoTime, M любых библиотек Java с открытым исходным кодом, таких как Apache commons lang, Google commons и Spring, также предоставляет служебный класс StopWatch, который можно использовать для измерения прошедшего времени в Java . StopWatch улучшает читабельность, сводя к минимуму ошибки вычислений при расчете истекшего времени выполнения, но имейте в виду, что StopWatch не является поточно- ориентированным и не должен использоваться совместно в многопоточной среде, а в его документации четко сказано, что это больше подходит для разработки и тестирования, а не для базовых измерений производительности. выполнение расчета времени в производственной среде.
Источник: coderlessons.com
Ценим время с потоками
Итак, предположим, что мы захотели набрать бутылку воды. В наличии имеются бутылка и кран с водой дяди Пети. Дяде Пете сегодня установили новый кран, и он без умолку нахваливал его красоту. До этого он пользовался только старым засорившимся краном, поэтому очереди на разливе были колоссальные.
Немного повозившись, со стороны разлива послышался звук набирающейся воды, спустя 2 минуты бутылка все еще находится в стадии наполнения, за нами собралась привычная очередь, а в голове рисуется образ того, как заботливый дядя Петя отбирает только лучшие молекулы H2O в нашу бутылку. Обученный жизнью дядя Петя успокаивает особо агрессивных и обещает закончить как можно быстрее. Покончив с бутылкой, он берет следующую и включает привычный напор, не раскрывающий всех возможностей нового крана. Люди не довольны…
Теория
Многопоточность – это свойство платформы создавать несколько потоков в рамках одного процесса. Создание и выполнение потока намного проще чем создание процесса, поэтому при необходимости реализовать несколько параллельных действий в одной программе используются дополнительные потоки. В JVM любая программа запускается в основном потоке, а уже из него запускаются остальные. В рамках одного процесса потоки способны обмениваться данными между собой. При запуске нового потока его можно объявить, как пользовательский с помощью метода
setDaemon(true);
- MIN_PRIORITY
- NORM_PRIORITY (default)
- MAX_PRIORITY
- run() – выполняет поток
- start() – запускает поток
- getName() – возвращает имя потока
- setName() – задает имя потока
- wait() – наследуемый метод, поток ожидает вызова метода notify() из другого потока
- notify() – наследуемый метод, возобновляет ранее остановленный поток
- notifyAll() – наследуемый метод, возобновляет ранее остановленные потоки
- sleep() – приостанавливает поток на заданное время
- join() – ждет завершения потока
- interrupt() – прерывает выполнение потока
- Доступ к сети
- Доступ к файловой системе
- GUI
Класс Thread
Потоки в Java представлены в виде класса Thread и его наследников. Приведенный ниже пример является простейшей реализацией потокового класса.
В результате получим
Основной поток Новый поток
Здесь мы создаем наш класс и делаем его наследником класса Thread , после чего пишем метод main() для запуска основного потока и переопределяем метод run() класса Thread . Теперь создав экземпляр нашего класса и выполнив его унаследованный метод start() мы запустим новый поток, в котором выполнится все что описано в теле метода run() . Звучит сложно, но взглянув на код примера все должно быть понятно.
Интерфейс Runnable
Oracle также предлагает для запуска нового потока реализовывать интерфейс Runnable , что дает нам большую гибкость в разработке, чем единственное доступное наследование в предыдущем примере (если заглянуть в исходники класса Thread можно увидеть, что он также реализует интерфейс Runnable ). Применим рекомендуемый метод создания нового потока.
В результате получим
Основной поток Новый поток
Примеры очень похожи, т.к. при написании кода нам пришлось реализовать абстрактный метод run() , описанный в интерфейсе Runnable . Запуск же нового потока немного отличается. Мы создали экземпляр класса Thread , передав в качестве параметра ссылку на экземпляр нашей реализации интерфейса Runnable . Именно такой подход позволяет создавать новые потоки без прямого наследования класса Thread .
Долгие операции
Следующий пример наглядно покажет преимущества использования нескольких потоков. Допустим у нас есть простая задача, требующая нескольких длительных вычислений, до этой статьи мы решали бы ее в методе main() возможно разбив для удобства восприятия на отдельные методы, может быть даже классы, но суть была бы одна. Все операции совершались бы последовательно одна за другой. Давайте смоделируем тяжеловесные вычисления и замерим время их выполнения.
public class ComputeClass < public static void main(String[] args) < // Узнаем стартовое время программы long startTime = System.currentTimeMillis(); // Определяем долгосрочные операции for(double i = 0; i < 999999999; i++)< >System.out.println(«complete 1»); for(double i = 0; i < 999999999; i++)< >System.out.println(«complete 2»); for(double i = 0; i < 999999999; i++)< >System.out.println(«complete 3»); //Вычисляем и выводим время выполнения программы long timeSpent = System.currentTimeMillis() — startTime; System.out.println(«программа выполнялась » + timeSpent + » миллисекунд»); > >
В результате получим
complete 1 complete 2 complete 3 программа выполнялась 9885 миллисекунд
Время выполнения оставляет желать лучшего, а мы все это время смотрим на пустой экран вывода, и ситуация очень смахивает на историю про дядю Петю только теперь в его роли мы, разработчики, не воспользовавшиеся всеми возможностями современных устройств. Будем исправляться.
В результате получим
complete 1 complete 2 complete 3 программа выполнялась 3466 миллисекунд
Время работы значительно сократилось (этот эффект может быть не достигнут или и вовсе увеличить время выполнения на процессорах не поддерживающих многопоточность). Стоит заметить, что потоки могут завершатся не по порядку, и если разработчику необходима предсказуемость действий он должен реализовать ее самостоятельно под конкретный случай.
Группы потоков
Потоки в Java можно объединять в группы, для этого используется класс ThreadGroup . В состав групп могут входить как одиночные потоки, так и целые группы. Это может оказаться удобным если вам надо прервать потоки связанные, например, с сетью при обрыве соединения. Подробнее о группах можно почитать здесь Надеюсь теперь тема стала вам более понятной и ваши пользователи будут довольны.
Источник: javarush.com