Как получить время выполнения метода? Есть ли укомплектованный класс Timer для таких вещей, как синхронизация времени выполнения задачи и т.д.?
Большинство поисковых запросов в Google возвращают результаты для таймеров, которые планируют потоки и задачи, чего я не хочу.
Всегда есть старомодный способ:
long startTime = System.nanoTime();
methodToTime();
long endTime = System.nanoTime();
long duration = (endTime - startTime); //divide by 1000000 to get milliseconds.
Я иду с простым ответом. Работает для меня.
long startTime = System.currentTimeMillis();
doReallyLongThing();
long endTime = System.currentTimeMillis();
System.out.println("That took " + (endTime - startTime) + " milliseconds");
Это работает очень хорошо. Разрешение, очевидно, только на миллисекунду, вы можете сделать лучше с System.nanoTime(). Существуют некоторые ограничения для обоих (срезы расписания операционной системы и т.д.), Но это работает очень хорошо.
В среднем за пару прогонов (тем лучше), и вы получите приличную идею.
Давай, ребята! Никто не упомянул Guava способ сделать это (что, возможно, удивительно):
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 +
Используя Instant и Duration из нового API Java 8,
Instant start = Instant.now();
Thread.sleep(5000);
Instant end = Instant.now();
System.out.println(Duration.between(start, end));
выходы,
PT5S
Используйте профилировщик (JProfiler, Netbeans Profiler, Visual VM, Eclipse Profiler и т.д.). Вы получите самые точные результаты и будете наименее навязчивыми. Они используют встроенный механизм JVM для профилирования, который также может предоставить вам дополнительную информацию, такую как трассировки стека, пути выполнения и более полные результаты, если это необходимо.
При использовании полностью интегрированного профилировщика тривиально профилировать метод. Щелкните правой кнопкой мыши, Профайлер → Добавить в Корневые методы. Затем запустите профайлер так же, как вы делали тестовый прогон или отладчик.
Собрались все возможные пути вместе в одном месте.
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);
Система. currentTimeMillis()
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;
}
Guava: Google Stopwatch 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 Lang JAR " StopWatch предоставляет удобный 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()) );
ДЖОДА -TIME
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());
}
Java date time API из Java 8 "Объект Duration представляет период времени между двумя объектами Instant.
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 предоставляет служебный класс StopWatch для измерения прошедшего времени в 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) {
System.out.format("[%s]:[%d]\n",
task.getTaskName(), task.getTimeMillis());
}
Выход:
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]
Это, вероятно, не то, что вы хотели, чтобы я сказал, но это хорошее использование АОП. Внесите прокси-перехватчик вокруг вашего метода и сделайте там время.
Что, почему и как АОП, к сожалению, выходит за рамки этого ответа, но как бы я это сделал.
Изменить: Здесь ссылка на Spring АОП, чтобы вы начали, если вы увлечены. Это самая доступная реализация AOP, с которой Iive сталкивается с java.
Кроме того, учитывая, что все остальные очень простые предложения, я должен добавить, что AOP предназначен, когда вы не хотите, чтобы такие вещи, как синхронизация, вторглись в ваш код. Но во многих случаях такой простой и легкий подход хорош.
System.currentTimeMillis(); НЕ подходит для измерения производительности ваших алгоритмов. Он измеряет общее время, которое вы испытываете, как пользователь, наблюдающий за экраном компьютера. Он включает также время, затрачиваемое на все остальное, работающее на вашем компьютере в фоновом режиме. Это может иметь огромное значение в случае, если на вашей рабочей станции имеется много программ.
Правильный подход заключается в использовании пакета java.lang.management.
Из http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking веб-сайт:
getCpuTime() дает вам сумму:
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
public class CPUUtils {
/** Get CPU time in nanoseconds. */
public static long getCpuTime( ) {
ThreadMXBean bean = ManagementFactory.getThreadMXBean( );
return bean.isCurrentThreadCpuTimeSupported( ) ?
bean.getCurrentThreadCpuTime( ) : 0L;
}
/** Get user time in nanoseconds. */
public static long getUserTime( ) {
ThreadMXBean bean = ManagementFactory.getThreadMXBean( );
return bean.isCurrentThreadCpuTimeSupported( ) ?
bean.getCurrentThreadUserTime( ) : 0L;
}
/** Get system time in nanoseconds. */
public static long getSystemTime( ) {
ThreadMXBean bean = ManagementFactory.getThreadMXBean( );
return bean.isCurrentThreadCpuTimeSupported( ) ?
(bean.getCurrentThreadCpuTime( ) - bean.getCurrentThreadUserTime( )) : 0L;
}
}
С помощью Java 8 вы можете сделать что-то подобное с помощью всех обычных методов:
Object returnValue = TimeIt.printTime(() -> methodeWithReturnValue());
//do stuff with your returnValue
с TimeIt вроде:
public class TimeIt {
public static <T> T printTime(Callable<T> task) {
T call = null;
try {
long startTime = System.currentTimeMillis();
call = task.call();
System.out.print((System.currentTimeMillis() - startTime) / 1000d + "s");
} catch (Exception e) {
//...
}
return call;
}
}
С помощью этого метода вы можете легко измерить время в любом месте вашего кода, не нарушая его. В этом простом примере я просто распечатываю время. Можно добавить переключатель для TimeIt, например. чтобы печатать только время в DebugMode или что-то в этом роде.
Если вы работаете с Функция, вы можете сделать что-то вроде этого:
Function<Integer, Integer> yourFunction= (n) -> {
return IntStream.range(0, n).reduce(0, (a, b) -> a + b);
};
Integer returnValue = TimeIt.printTime2(yourFunction).apply(10000);
//do stuff with your returnValue
public static <T, R> Function<T, R> printTime2(Function<T, R> task) {
return (t) -> {
long startTime = System.currentTimeMillis();
R apply = task.apply(t);
System.out.print((System.currentTimeMillis() - startTime) / 1000d
+ "s");
return apply;
};
}
Также мы можем использовать класс StopWatch для сообщества Apache для измерения времени.
Пример кода
org.apache.commons.lang.time.StopWatch sw = new org.apache.commons.lang.time.StopWatch();
System.out.println("getEventFilterTreeData :: Start Time : " + sw.getTime());
sw.start();
// Method execution code
sw.stop();
System.out.println("getEventFilterTreeData :: End Time : " + sw.getTime());
Просто небольшой поворот, если вы не используете инструментарий и хотите использовать методы времени с низким временем выполнения: выполните его много раз, каждый раз удваивая количество раз, когда оно выполняется до тех пор, пока вы не достигнете секунды или около того. Таким образом, время вызова в System.nanoTime и т.д., А также точность System.nanoTime существенно влияет на результат.
int runs = 0, runsPerRound = 10;
long begin = System.nanoTime(), end;
do {
for (int i=0; i<runsPerRound; ++i) timedMethod();
end = System.nanoTime();
runs += runsPerRound;
runsPerRound *= 2;
} while (runs < Integer.MAX_VALUE / 2 && 1000000000L > end - begin);
System.out.println("Time for timedMethod() is " +
0.000000001 * (end-begin) / runs + " seconds");
Конечно, существуют оговорки об использовании настенных часов: влияние JIT-компиляции, несколько потоков/процессов и т.д. Таким образом, вам нужно сначала выполнить метод много раз во-первых, чтобы компилятор JIT выполнял свою работу, а затем повторите этот тест несколько раз и выполните самое низкое время выполнения.
Мы используем аннотации AspectJ и Java для этой цели. Если нам нужно знать время выполнения для метода, мы просто аннотируем его. Более продвинутая версия может использовать собственный уровень журнала, который можно включить и отключить во время выполнения.
public @interface Trace {
boolean showParameters();
}
@Aspect
public class TraceAspect {
[...]
@Around("tracePointcut() && @annotation(trace) && !within(TraceAspect)")
public Object traceAdvice ( ProceedingJintPoint jP, Trace trace ) {
Object result;
// initilize timer
try {
result = jp.procced();
} finally {
// calculate execution time
}
return result;
}
[...]
}
Действительно хороший код.
http://www.rgagnon.com/javadetails/java-0585.html
import java.util.concurrent.TimeUnit;
long startTime = System.currentTimeMillis();
........
........
........
long finishTime = System.currentTimeMillis();
String diff = millisToShortDHMS(finishTime - startTime);
/**
* converts time (in milliseconds) to human-readable format
* "<dd:>hh:mm:ss"
*/
public static String millisToShortDHMS(long duration) {
String res = "";
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));
if (days == 0) {
res = String.format("%02d:%02d:%02d", hours, minutes, seconds);
}
else {
res = String.format("%dd%02d:%02d:%02d", days, hours, minutes, seconds);
}
return res;
}
К вашему сведению, JEP 230: Microbenchmark Suite является проектом OpenJDK для:
Добавьте базовый набор микробенчмарков в исходный код JDK и упростите разработчикам запуск существующих микробенчмарков и создание новых.
Эта функция появилась в Java 12.
Для более ранних версий Java взгляните на проект Java Microbenchmark Harness (JMH), на котором основан JEP 230.
Вы можете использовать Perf4j. Очень крутая утилита. Использование прост
String watchTag = "target.SomeMethod";
StopWatch stopWatch = new LoggingStopWatch(watchTag);
Result result = null; // Result is a type of a return value of a method
try {
result = target.SomeMethod();
stopWatch.stop(watchTag + ".success");
} catch (Exception e) {
stopWatch.stop(watchTag + ".fail", "Exception was " + e);
throw e;
}
Более подробную информацию можно найти в Руководство разработчика
Изменить: Проект кажется мертвым
new Timer(""){{
// code to time
}}.timeMe();
public class Timer {
private final String timerName;
private long started;
public Timer(String timerName) {
this.timerName = timerName;
this.started = System.currentTimeMillis();
}
public void timeMe() {
System.out.println(
String.format("Execution of '%s' takes %dms.",
timerName,
started-System.currentTimeMillis()));
}
}
Я в основном делаю вариации этого, но, учитывая, как работает компиляция точек доступа, если вы хотите получить точные результаты, вам нужно выбросить первые несколько измерений и убедиться, что вы используете этот метод в реальном мире (читайте приложение) выражение.
Если JIT решит скомпилировать его, ваши номера будут сильно различаться. поэтому просто знайте
Используя аннотации AOP/AspectJ и @Loggable из jcabi-aspect, вы можете сделать это легко и компактно:
@Loggable(Loggable.DEBUG)
public String getSomeResult() {
// return some value
}
Каждый вызов этого метода будет отправляться в средство ведения журнала SLF4J с уровнем ведения журнала DEBUG. И каждое сообщение журнала будет включать время выполнения.
Есть несколько способов сделать это. Обычно я возвращаюсь к тому, чтобы просто использовать что-то вроде этого:
long start = System.currentTimeMillis();
// ... do something ...
long end = System.currentTimeMillis();
или то же самое с System.nanoTime();
Для чего-то большего на сравнительной стороне вещей, похоже, также есть этот: http://jetm.void.fm/ Никогда не пробовал.
Spring предоставляет класс утилиты org.springframework.util.StopWatch в соответствии с JavaDoc:
Простой секундомер, позволяющий синхронизировать ряд задач, выставляя общее время работы и время выполнения для каждой именованной задачи.
Использование:
StopWatch stopWatch = new StopWatch("Performance Test Result");
stopWatch.start("Method 1");
doSomething1();//method to test
stopWatch.stop();
stopWatch.start("Method 2");
doSomething2();//method to test
stopWatch.stop();
System.out.println(stopWatch.prettyPrint());
Вывод:
StopWatch 'Performance Test Result': running time (millis) = 12829
-----------------------------------------
ms % Task name
-----------------------------------------
11907 036% Method 1
00922 064% Method 2
С аспектами:
@Around("execution(* my.package..*.*(..))")
public Object logTime(ProceedingJoinPoint joinPoint) throws Throwable {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
Object retVal = joinPoint.proceed();
stopWatch.stop();
log.info(" execution time: " + stopWatch.getTotalTimeMillis() + " ms");
return retVal;
}
Я написал метод для печати времени выполнения метода в удобочитаемой форме. Например, чтобы вычислить факториал в 1 миллион, потребуется приблизительно 9 минут. Таким образом, время выполнения печатается как:
Execution Time: 9 Minutes, 36 Seconds, 237 MicroSeconds, 806193 NanoSeconds
Код здесь:
public class series
{
public static void main(String[] args)
{
long startTime = System.nanoTime();
long n = 10_00_000;
printFactorial(n);
long endTime = System.nanoTime();
printExecutionTime(startTime, endTime);
}
public static void printExecutionTime(long startTime, long endTime)
{
long time_ns = endTime - startTime;
long time_ms = TimeUnit.NANOSECONDS.toMillis(time_ns);
long time_sec = TimeUnit.NANOSECONDS.toSeconds(time_ns);
long time_min = TimeUnit.NANOSECONDS.toMinutes(time_ns);
long time_hour = TimeUnit.NANOSECONDS.toHours(time_ns);
System.out.print("\nExecution Time: ");
if(time_hour > 0)
System.out.print(time_hour + " Hours, ");
if(time_min > 0)
System.out.print(time_min % 60 + " Minutes, ");
if(time_sec > 0)
System.out.print(time_sec % 60 + " Seconds, ");
if(time_ms > 0)
System.out.print(time_ms % 1E+3 + " MicroSeconds, ");
if(time_ns > 0)
System.out.print(time_ns % 1E+6 + " NanoSeconds");
}
}
Если вы хотите время настенных часов
long start_time = System.currentTimeMillis();
object.method();
long end_time = System.currentTimeMillis();
long execution_time = end_time - start_time;
Как сказал "skaffman", используйте AOP ИЛИ вы можете использовать время выполнения байт-кода, точно так же, как инструменты покрытия метода модульного теста используют для прозрачного добавления информации о синхронизации к вызываемым методам.
Вы можете посмотреть на код, используемый инструментами с открытым исходным кодом, такими как Emma (http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0). Другой инструмент покрытия с открытым исходным кодом - http://prdownloads.sourceforge.net/cobertura/cobertura-1.9-src.zip?download.
Если вам в конечном итоге удастся сделать то, что вы изложили, пожалуйста. поделитесь этим с сообществом здесь с вашей задачей/банками муравья.
long startTime = System.currentTimeMillis();
// code goes here
long finishTime = System.currentTimeMillis();
long elapsedTime = finishTime - startTime; // elapsed time in milliseconds
Я изменил код из правильного ответа, чтобы получить результат в секундах:
long startTime = System.nanoTime();
methodCode ...
long endTime = System.nanoTime();
double duration = (double)(endTime - startTime) / (Math.pow(10, 9));
Log.v(TAG, "MethodName time (s) = " + duration);
Вы можете использовать Metrics библиотеку, которая предоставляет различные измерительные приборы. Добавить зависимость:
<dependencies>
<dependency>
<groupId>io.dropwizard.metrics</groupId>
<artifactId>metrics-core</artifactId>
<version>${metrics.version}</version>
</dependency>
</dependencies>
И настройте его для своей среды.
Методы могут быть аннотированы с помощью @Timed:
@Timed
public void exampleMethod(){
// some code
}
или фрагмент кода, завернутый в Timer:
final Timer timer = metricsRegistry.timer("some_name");
final Timer.Context context = timer.time();
// timed code
context.stop();
Агрегированные показатели могут экспортироваться в консоль, JMX, CSV или другие.
@Timed Пример вывода показателей:
com.example.ExampleService.exampleMethod
count = 2
mean rate = 3.11 calls/minute
1-minute rate = 0.96 calls/minute
5-minute rate = 0.20 calls/minute
15-minute rate = 0.07 calls/minute
min = 17.01 milliseconds
max = 1006.68 milliseconds
mean = 511.84 milliseconds
stddev = 699.80 milliseconds
median = 511.84 milliseconds
75% <= 1006.68 milliseconds
95% <= 1006.68 milliseconds
98% <= 1006.68 milliseconds
99% <= 1006.68 milliseconds
99.9% <= 1006.68 milliseconds
Вы можете использовать класс секундомера из основного проекта Spring:
Код:
StopWatch stopWatch = new StopWatch()
stopWatch.start(); //start stopwatch
// write your function or line of code.
stopWatch.stop(); //stop stopwatch
stopWatch.getTotalTimeMillis() ; ///get total time
Документация для секундомера: простой секундомер, позволяющий рассчитывать время выполнения ряда задач, показывая общее время выполнения и время выполнения для каждой названной задачи. Скрывает использование System.currentTimeMillis(), улучшая читабельность кода приложения и уменьшая вероятность ошибок вычислений. Обратите внимание, что этот объект не предназначен для работы с потоками и не использует синхронизацию. Этот класс обычно используется для проверки производительности во время проверки концепции и в процессе разработки, а не как часть производственных приложений.
Вы можете попробовать, если хотите узнать время.
long startTime = System.currentTimeMillis();
//@ Method call
System.out.println("Total time [ms]: " + (System.currentTimeMillis() - startTime));
Хорошо, это простой класс, который можно использовать для простой простой синхронизации ваших функций. Ниже приведен пример.
public class Stopwatch {
static long startTime;
static long splitTime;
static long endTime;
public Stopwatch() {
start();
}
public void start() {
startTime = System.currentTimeMillis();
splitTime = System.currentTimeMillis();
endTime = System.currentTimeMillis();
}
public void split() {
split("");
}
public void split(String tag) {
endTime = System.currentTimeMillis();
System.out.println("Split time for [" + tag + "]: " + (endTime - splitTime) + " ms");
splitTime = endTime;
}
public void end() {
end("");
}
public void end(String tag) {
endTime = System.currentTimeMillis();
System.out.println("Final time for [" + tag + "]: " + (endTime - startTime) + " ms");
}
}
Пример использования:
public static Schedule getSchedule(Activity activity_context) {
String scheduleJson = null;
Schedule schedule = null;
/*->*/ Stopwatch stopwatch = new Stopwatch();
InputStream scheduleJsonInputStream = activity_context.getResources().openRawResource(R.raw.skating_times);
/*->*/ stopwatch.split("open raw resource");
scheduleJson = FileToString.convertStreamToString(scheduleJsonInputStream);
/*->*/ stopwatch.split("file to string");
schedule = new Gson().fromJson(scheduleJson, Schedule.class);
/*->*/ stopwatch.split("parse Json");
/*->*/ stopwatch.end("Method getSchedule");
return schedule;
}
Пример вывода консоли:
Split time for [file to string]: 672 ms
Split time for [parse Json]: 893 ms
Final time for [get Schedule]: 1565 ms
В Java 8 вводится новый класс с именем Instant. Согласно документу:
Мгновенное действие представляет собой начало наносекунды на временной линии. Эта класс полезен для создания метки времени для представления машинного времени. Для диапазона времени требуется хранить число, большее, чем длинный. Для этого класс хранит длинное представление epoch-seconds и int, представляющие наносекундную секунду, что всегда между 0 и 999999999. Измерены периоды эпохи от стандартной эпохи Java 1970-01-01T00: 00: 00Z, где моменты после эпохи имеют положительные значения, а более ранние моменты имеют отрицательные значения. Как для эпох-вторых, так и для наносекундных частей большее значение всегда находится на временной линии, чем меньшее значение.
Это можно использовать как:
Instant start = Instant.now();
try {
Thread.sleep(7000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Instant end = Instant.now();
System.out.println(Duration.between(start, end));
Он печатает PT7.001S.