Javaでメソッドの実行のタイミングをどのように計りますか?


834
  1. メソッドの実行時間を取得するにはどうすればよいですか?
  2. Timerタスクの所要時間などのユーティリティクラスはありますか?

Googleでの検索のほとんどは、スレッドとタスクをスケジュールするタイマーの結果を返しますが、これは私が望んでいることではありません。


JAMon APIは、開発者が本番アプリケーションのパフォーマンスとスケーラビリティを簡単に監視できる、無料のシンプルで高性能なスレッドセーフのJava APIです。JAMonは、ヒット、実行時間(合計、平均、最小、最大、標準偏差)などを追跡します。http://jamonapi.sourceforge.net/ download:http
//sourceforge.net/project/showfiles.php

1
また、Apache Commons Lang StopWatchクラスを確認することもできます。シンプルだが便利なユーティリティクラス。


はい、StopWatchはこれに最適です。
Shubham Pandey

Instantクラスを使用するJava 8 :stackoverflow.com/a/30975902/1216775
akhil_mittal

回答:


1207

常に昔ながらの方法があります。

long startTime = System.nanoTime();
methodToTime();
long endTime = System.nanoTime();

long duration = (endTime - startTime);  //divide by 1000000 to get milliseconds.

233
実際には、Java5まで追加されなかったnanoTimeを使用したため、その「新式」
John Gardner

11
これ(またはSystem.currentTimeMillis()を使用)は、Javaで通常行われている方法のようです...私はとにかく見ました。それでも、Timer t = new Timer();のような洗練された組み込みクラスがないことを私は少し驚いています。文字列s = t.getElapsed(format); etc ...
Ogre Psalm33 2008年

18
nanoTimeはcurrentTimeMillis()よりも精度を保証しませんが、通常は保証します。forums.sun.com/thread.jspa?messageID=9460663およびsimongbrown.com/blog/2007/08/20/…–
James

10
もちろん、結果をゆがめる可能性のあるコンパイラ/ JVM最適化などのマイクロベンチマークの落とし穴を覚えておくことは常に重要です= 8
Yuval

18
例外がスローされた場合、endTimeは使用されないため、finallyブロックは必要ありません。
Peter Lawrey、

197

私は簡単な答えで行きます。私のために働く。

long startTime = System.currentTimeMillis();

doReallyLongThing();

long endTime = System.currentTimeMillis();

System.out.println("That took " + (endTime - startTime) + " milliseconds");

それはかなりうまくいきます。解像度は明らかにミリ秒単位であり、System.nanoTime()を使用するとより良い結果が得られます。両方にいくつかの制限(オペレーティングシステムのスケジュールスライスなど)がありますが、これはかなりうまく機能します。

数回の実行の平均(より良い)で、適切なアイデアが得られます。


51
実際、System.currentTimeMillis()は15ms以上でのみ正確です。非常に低い値の場合は、信頼できません。これに対する解決策(前述のとおり)はSystem.nanoTime();です。
スティーブg

さて、Steve gのコメントを読むまで、これを公式の回答として受け入れようとしていました。スティーブ!
Ogre Psalm33

4
nanoTime()はcurrentTimeMillisよりも精度を保証しませんが、多くのJVM実装はnanoTimeで精度が高くなっています。
James Schek、2008年

5
@JamesSchek他の場所でこの同じコメントについてすでに述べたように、あなたは本当にあなたの言い回しを監視する必要があります。nanoTime、少なくともと同じように断固として保証されますcurrentTimeMillisdocs.oracle.com/javase/7/docs/api/java/lang/...
b1nary.atr0phy

の1つのわずかな利点currentTimeMillisは、それが実際のタイムスタンプであり、開始/終了時間のログにnanoTimeも使用できることです。「経過時間の測定にのみ使用でき、システムまたは壁時計時間の他の概念とは関係ありません。 」
ブラッドパークス

177

みんなおいでよ!グアバがそれを行う方法については誰も言及していません(これは間違いなく素晴らしいです)。

import com.google.common.base.Stopwatch;

Stopwatch timer = Stopwatch.createStarted();
//method invocation
LOG.info("Method took: " + timer.stop());

良い点は、Stopwatch.toString()が測定の時間単位を適切に選択できることです。つまり、値が小さい場合は38 nsを出力し、長い場合は5m 3sを表示します

さらに良い:

Stopwatch timer = Stopwatch.createUnstarted();
for (...) {
   timer.start();
   methodToTrackTimeFor();
   timer.stop();
   methodNotToTrackTimeFor();
}
LOG.info("Method took: " + timer);

注:Google GuavaにはJava 1.6以降が必要です


21
残念ながら、Guavaのストップウォッチはスレッドセーフではありません。私はこれを難しい方法で学びました。
デクスターLegaspi 2014

6
@DexterLegaspiあなたの経験に非常に興味があります!共有しますか?
Siddhartha、2015年

1
ストップウォッチを並行して使用するとstart()、続けて複数回呼び出すことになります(と同じstop())。
Mingwei Samuel

141

Java 8の新しいAPIのInstantDurationを使用して、

Instant start = Instant.now();
Thread.sleep(5000);
Instant end = Instant.now();
System.out.println(Duration.between(start, end));

出力、

PT5S

2
ありがとう、PTを前面に表示せずに結果を出力するにはどうすればよいですか?
java123999 2016年

1
メソッドの問題は、Instantがミリ秒とナノ秒の精度を問題としないことです。参照:stackoverflow.com/questions/20689055/…–
prashantsunkari

8
@ java123999:を呼び出すことができますDuration.between(start, end).getSeconds()DurationまたtoMillis()、ミリ秒に変換するなど、他の時間単位に変換するメソッドもあります。
Emil Lunde、

100

すべての可能な方法を1つの場所にまとめました。

日付

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;
}

グアバ: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 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()) );

JODA -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 8のJava日時API « 期間オブジェクトは、2つのインスタントオブジェクト間の期間を表します。

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ユーティリティクラスを提供します。

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]

Guava、Apache Commons、Spring Frameworkのストップウォッチはスレッドセーフではありません。本番環境での使用は安全ではありません。
Deepak Puthraya

@DeepakPuthrayaでは、どのライブラリを使用すれば、本番環境で使用しても安全ですか?
gaurav

1
@DeepakPuthrayaでは、Java 8提供のJava日時APIを使用できます。それは簡単です。
Yash

IMOこの投稿は、すべてのソリューションがシステム出力の出力も表示する場合にメリットがあります。
BAERUS

87

プロファイラー(JProfiler、Netbeansプロファイラー、Visual VM、Eclipseプロファイラーなど)を使用します。最も正確な結果が得られ、煩わしさが最も少なくなります。組み込みのJVMメカニズムを使用してプロファイリングを行うため、スタックトレース、実行パス、さらに必要に応じてより包括的な結果などの追加情報も提供できます。

完全に統合されたプロファイラーを使用する場合、メソッドのプロファイリングは簡単です。右クリック、プロファイラー->ルートメソッドに追加。次に、テスト実行またはデバッガーを実行するのと同じようにプロファイラーを実行します。


これも素晴らしい提案でした。私がこの回答を読んだとき、私にとっては、それらの「だ」電球の瞬間の1つでした。私たちのプロジェクトではJDeveloperを使用していますが、私は確認しましたが、確かに、組み込みのプロファイラーがあります。
Ogre Psalm33、2008年

2
Java 7ビルド40(私は思う)から、以前のJRockits Flight RecorderからJava(Java Mission Controlを検索)まで含めました
Niels Bech Nielsen 14年


たとえば、Visual VMによってJavaでメソッドの実行を取得する方法は?
okwap 2014年

41

これはおそらくあなたが私に言って欲しかったことではありませんが、これはAOPの良い使い方です。メソッドの周りにプロキシインターセプターを仕掛け、そこでタイミングを計ります。

残念ながら、AOPの何を、なぜ、どのように処理するかは、この回答の範囲を超えていますが、それで私はそうするでしょう。

編集:必要に応じて、始めるためのSpring AOPへのリンク以下に示します。これは、IiveがJavaで遭遇した最もアクセスしやすいAOPの実装です。

また、他の皆の非常に単純な提案を考えると、タイミングのようなものがコードに侵入したくない場合のためにAOPを追加する必要があることを付け加えておきます。しかし、多くの場合、そのような単純で簡単なアプローチで十分です。


3
ここでは春でこれを行う方法についてのチュートリアルは次のとおりです。veerasundar.com/blog/2010/01/...
デヴィッド・ティンカー

39

System.currentTimeMillis();アルゴリズムのパフォーマンスを測定するための良いアプローチではありません。これは、ユーザーがコンピューターの画面を見ているときに経験する合計時間を測定します。また、バックグラウンドでコンピューター上で実行されている他のすべてのものによって消費された時間も含まれます。ワークステーションで多数のプログラムを実行している場合、これは大きな違いをもたらす可能性があります。

適切なアプローチはjava.lang.managementパッケージを使用しています。

http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking Webサイトから:

  • 「ユーザー時間」は、アプリケーション独自のコードの実行に費やされた時間です。
  • 「システム時間」は、アプリケーションに代わってOSコードの実行に費やされた時間です(I / Oなど)。

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;
    }

}

4
これは間違いなく良い点です。「ユーザー時間」(実時間)は、特にマルチスレッドプログラムでは、必ずしもパフォーマンスの優れた指標とは限りません。
Ogre Psalm33 2014

これが私が探している答えです。
ZhaoGang

30

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;
    };
}

これは他のソリューションよりもはるかに良く見えます。Spring AOPに近いが、それよりも軽い。真のjava 8方法!+1ありがとうございます!
Amit Kumar 2017

ステファンがファンシーな新しいJava関数を使用しているので、これはあなたには良さそうです。しかし、これを読んで理解するのは非常に難しいと思います。
Stimpson Cat、

18

また、Apache commonsのStopWatchクラスを使用して時間を測定することもできます。

サンプルコード

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());

15

ツールを使用せず、実行時間の短いメソッドの時間を計測したい場合は、少し工夫してください。毎回実行する回数は、1秒に達するまで実行回数を2倍にするなどです。したがって、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コンパイラがその仕事をするように、最初の回のを、その後、このテストを複数回繰り返し、実行時間が最も短くなります。


13

この目的のために、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;
  }
  [...]
}

13

JEP 230:マイクロベンチマークスイート

参考までに、JEP 230:Microbenchmark Suiteは、次のことを行うOpenJDKプロジェクトです。

JDKソースコードにマイクロベンチマークの基本スイートを追加し、開発者が既存のマイクロベンチマークを実行して新しいものを簡単に作成できるようにします。

この機能はJava 12で導入されました。

Java Microbenchmark Harness(JMH)

以前のバージョンのJavaについては、JEP 230のベースとなっているJava Microbenchmark Harness(JMH)プロジェクトをご覧ください。


11

本当に良いコードです。

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;
  }

3
実際の問題は、メソッドをフォーマットする方法ではなく、メソッドにかかる時間を計算する方法でした。ただし、この質問はかなり古いものです(ほぼ4年です!)。応答が既存の応答よりも新しく重要なものを追加しない限り、古いスレッドの復活を避けるようにしてください。
リージュン

1
そして、最後に残っているミリ秒を追加するには、次の変更を行います long millis = TimeUnit.MILLISECONDS.toMillis(duration) - TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(duration)); if (days == 0) { res = String.format("%02d:%02d:%02d.%02d", hours, minutes, seconds, millis); } else { res = String.format("%dd%02d:%02d:%02d.%02d", days, hours, minutes, seconds, millis); }
リックBarkhouse

10

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; 
}

詳細については、デベロッパーガイドをご覧ください。

編集:プロジェクトは死んでいるようです


1
Perf4jは、優れた統計も生成できます
Paaske 2012年

8
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()));
    }

}

1
ビルドシステムと依存するOTSがすでに設定されていて、ユーティリティタイマークラスを含む別のOTSパッケージをプルインしたくない場合は、独自のシンプルなクラスをロールするのが良い選択です。
Ogre Psalm33 2013

7

私は基本的にこれのバリエーションを行いますが、ホットスポットのコンパイルがどのように機能するかを考えると、正確な結果を得たい場合は、最初の数回の測定を破棄し、実際の(読み取りアプリケーション固有の)アプリケーションでメソッドを使用していることを確認する必要があります。

JITがコンパイルすることを決定した場合、数値は大きく異なります。だから気をつけて


7

AOP / AspectJとjcabi-aspects@Loggableからのアノテーションを使用すると、簡単かつコンパクトに実行できます。

@Loggable(Loggable.DEBUG)
public String getSomeResult() {
  // return some value
}

このメソッドへのすべての呼び出しは、DEBUGロギングレベルとともにSLF4Jロギングファシリティに送信されます。また、すべてのログメッセージには実行時間が含まれます。


7

Springは、JavaDocに従って、ユーティリティクラスorg.springframework.util.StopWatchを提供します。

単純なストップウォッチ。多数のタスクのタイミングを可能にし、合計実行時間と各名前付きタスクの実行時間を公開します。

使用法:

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;
}

これをAspectJで使用することは可能ですか?
zygimantus、2015年

7

メソッドの実行時間を読みやすい形式で出力するメソッドを作成しました。たとえば、100万の階乗を計算するには、約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");
    }
}

6

これを行うにはいくつかの方法があります。私は通常、次のようなものを使用することにフォールバックします。

long start = System.currentTimeMillis();
// ... do something ...
long end = System.currentTimeMillis();

またはSystem.nanoTime();と同じこと

物事のベンチマークの側面については、これもあるようです:http : //jetm.void.fm/試したことはありません。


6

さまざまな測定器を提供するメトリックライブラリを使用できます。依存関係を追加します。

<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

5

壁掛け時計が欲しいなら

long start_time = System.currentTimeMillis();
object.method();
long end_time = System.currentTimeMillis();
long execution_time = end_time - start_time;

5

「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です。

あなたが最終的にあなたが着手したことをなんとか成し遂げたら、pls。ant task / jarを使用して、コミュニティーと共有してください。


4
long startTime = System.currentTimeMillis();
// code goes here
long finishTime = System.currentTimeMillis();
long elapsedTime = finishTime - startTime; // elapsed time in milliseconds

4

私は数秒で結果を得るために正しい答えからコードを修正しました:

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);

4

Spring Coreプロジェクトのストップウォッチクラスを使用できます。

コード:

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()の使用を隠蔽し、アプリケーションコードの可読性を向上させ、計算エラーの可能性を減らします。このオブジェクトはスレッドセーフに設計されておらず、同期を使用しないことに注意してください。このクラスは通常、本番アプリケーションの一部としてではなく、概念実証中および開発中のパフォーマンスを検証するために使用されます。


3

時間を知りたいだけなら、この方法を試すことができます。

long startTime = System.currentTimeMillis();
//@ Method call
System.out.println("Total time [ms]: " + (System.currentTimeMillis() - startTime));    

3

わかりました、これは、関数の単純な単純なタイミングに使用される単純なクラスです。その下に例があります。

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

3

Java 8では、という名前の新しいクラスInstantが導入されています。ドキュメントに従って:

インスタントは、タイムライン上のナノ秒の開始を表します。このクラスは、マシンの時刻を表すタイムスタンプを生成するのに役立ちます。インスタントの範囲には、ロングよりも大きい数のストレージが必要です。これを実現するために、クラスはエポック秒を表すlongとナノ秒を表すintを格納します。これは常に0から999,999,999の間です。エポック秒は、1970-01-01T00:00:00Zの標準Javaエポックから測定されます。エポックの後の瞬間は正の値を持ち、それ以前の瞬間は負の値を持ちます。エポック秒とナノ秒の両方の部分で、大きい値は常に小さい値よりタイムライン上で遅くなります。

これは次のように使用できます。

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ます。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.