je vais avec la réponse simple. Fonctionne pour moi.

long startTime = System.currentTimeMillis();

doReallyLongThing();

long endTime = System.currentTimeMillis();

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

ça marche plutôt bien. La résolution est évidemment seulement à la milliseconde, vous pouvez faire mieux avec le système.nanoTime(). Il y a certaines limites aux deux (tranches de programme du système d'exploitation, etc.), mais cela fonctionne assez bien.

moyenne sur quelques descentes (le plus le mieux) et vous obtiendrez une idée décente.

allez les gars! Personne n'a mentionné la Goyave façon de faire cela (qui est sans doute génial):

import com.google.common.base.Stopwatch;

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

ce qui est bien, c'est ce Chronomètre.toString() fait un bon travail de sélection des unités de temps de la mesure. C'est-à-dire: si la valeur est petite, elle affichera 38 ns, si elle est longue, elle affichera 5m 3s

encore plus beau:

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

Note: Google Guava nécessite Java 1.6+

utilisant Instant et Duration de la nouvelle API Java 8,

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

sorties,

PT5S

utiliser un profiler (JProfiler, Netbeans Profiler, Visual VM, Eclipse Profiler, etc.). Vous obtiendrez les résultats les plus précis et le moins intrusif possible. Ils utilisent le mécanisme JVM intégré pour le profilage qui peut également vous donner des informations supplémentaires comme les traces de la pile, les chemins d'exécution, et des résultats plus complets si nécessaire.

lorsqu'on utilise un profileur entièrement intégré, il est trivial de profiler une méthode. Clic droit, Profiler - > Ajouter aux méthodes Root. Ensuite, exécutez l' profiler comme vous le faisiez un essai ou un débogueur.

a rassemblé tous les moyens possibles en un seul endroit.

Date

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

système. 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 ) );

Lisible Format

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

Goyave: Google Chronomètre ^JAR " un objet de chronomètre est de mesurer le temps écoulé en nanosecondes.

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 " Chronomètre est un outil pratique de l'API pour les horaires.

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 date du temps de l'API de Java 8 " Durée objet représente une période de temps entre deux Instantanée des objets.

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 offre Chronomètre utilitaire classe pour mesurer le temps écoulé En 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());
}

sortie:

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]

ce n'est probablement pas ce que vous vouliez que je dise, mais c'est une bonne utilisation d'AOP. Fouet un proxy intercepteur autour de votre méthode, et ne le calendrier.

le quoi, le pourquoi et le comment d'AOP dépasse la portée de cette réponse, malheureusement, mais c'est comme ça que je le ferais probablement.

Edit: Voici un lien Spring AOP pour vous aider, si vous êtes désireux de. Il s'agit de la mise en œuvre la plus accessible de la POA across pour java.

aussi, étant donné les suggestions très simples de tout le monde, je devrais ajouter que AOP est pour quand vous ne voulez pas que des choses comme le timing envahissent votre code. Mais dans de nombreux cas, ce genre d'approche simple et facile est très bien.

System.currentTimeMillis(); N'est pas une bonne approche pour mesurer la performance de vos algorithmes. Il mesure le temps total que vous vivez en tant qu'utilisateur regardant l'écran d'ordinateur. Il inclut également le temps consommé par tout ce qui fonctionne sur votre ordinateur à l'arrière-plan. Cela pourrait faire une énorme différence dans le cas où vous avez beaucoup de programmes en cours d'exécution sur votre poste de travail.

l'approche appropriée consiste à utiliser le paquet java.lang.management .

de http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking site web:

• "temps de L'utilisateur" est le temps passé à exécuter le propre code de votre application.
• Système "temps" est le temps passé à exécuter des codes du système d'exploitation sur le nom de votre application (comme pour les I/O).

getCpuTime() la méthode vous donne la somme de ceux-ci:

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

}

avec Java 8 Vous pouvez aussi faire quelque chose comme cela avec chaque méthodes :

Object returnValue = TimeIt.printTime(() -> methodeWithReturnValue());
//do stuff with your returnValue

avec TimeIt comme:

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

avec cette méthode, vous pouvez facilement mesurer le temps n'importe où dans votre code sans le casser. Dans cet exemple simple, je n'imprime que l'heure. Pouvez-vous ajouter un interrupteur pour TimeIt, par exemple pour imprimer uniquement le temps en mode de débogage ou quelque chose.

Si vous travaillez avec fonction vous pouvez faire quelque chose comme ceci:

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

nous pouvons aussi utiliser la classe StopWatch D'Apache commons pour mesurer le temps.

code échantillon

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

juste une petite torsion, si vous n'utilisez pas d'outils et que vous voulez chronométrer les méthodes avec un temps d'exécution faible: exécutez-le plusieurs fois, en doublant à chaque fois le nombre de fois qu'il est exécuté jusqu'à ce que vous atteigniez une seconde, ou plus. Ainsi, le temps de l'Appel Système.nanoTime et ainsi de suite, ni la précision du système.nanoTime affecte beaucoup le résultat.

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

bien sûr, les mises en garde sur l'utilisation de l'horloge murale s'appliquent: influences de JIT-compilation, fils multiples / les processus etc. Ainsi, vous devez d'abord exécuter la méthode beaucoup de fois d'abord, de sorte que le compilateur JIT fait son travail, puis répéter ce test plusieurs fois et prendre le plus bas temps d'exécution.

nous utilisons des annotations AspectJ et Java à cet effet. Si nous avons besoin de savoir à temps d'exécution pour une méthode, nous annotons simple. Une version plus avancée pourrait utiliser son propre niveau de log qui peut être activé et désactivé à l'exécution.

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;
  }
  [...]
}

très bon code.

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

pour info, JEP 230: Microbenchmark Suite est un OpenJDK proposition:

ajoute une suite de microbenchmarks de base au code source JDK, et rend facile pour les développeurs d'exécuter des microbenchmarks existants et d'en créer de nouveaux.

Cette proposition n'a de ne pas faire la coupe pour Java 9 , mais il peut être ajoutés plus tard.

Java Microbenchmark Harness (JMH)

dans l'intervalle, vous voudrez peut-être regarder le projet Java Microbenchmark Harn (JMH) sur lequel la proposition est basé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()));
    }

}

vous pouvez utiliser Perf4j . Très cool utilitaire. L'Usage est simple

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

plus d'information peut être trouvée dans Developer Guide

Edit: Projet semble mort

utilisant AOP/AspectJ et @Loggable annotation de jcabi-aspects you can do it easy and compact:

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

chaque appel à cette méthode sera envoyé à L'installation de journalisation SLF4J avec le niveau de journalisation DEBUG . Et chaque message log comprendra le temps d'exécution.

je fais essentiellement des variations de cela, mais compte tenu de la façon dont la compilation hotspot fonctionne, si vous voulez obtenir des résultats précis, vous devez jeter les premières mesures et assurez-vous que vous utilisez la méthode dans un monde réel (Lire application spécifique) application.

si le JIT décide de le compiler, votre nombre variera fortement. donc, juste être conscient

il y a plusieurs façons de le faire. Je retombe normalement à utiliser quelque chose comme ceci:

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

ou la même chose avec le Système.nanoTime ();

pour quelque chose de plus sur le côté benchmarking des choses il semble y avoir aussi celui-ci: http://jetm.void.fm / N'a jamais essayé.

Si vous voulez horloge murale

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

comme" skaffman " dit, utilisez AOP ou vous pouvez utiliser le tissage de bytecode de temps d'exécution, tout comme les outils de couverture de méthode d'essai unitaire utilisent pour ajouter de manière transparente des informations de synchronisation aux méthodes invoquées.

vous pouvez regarder le code utilisé par les outils open source outils comme Emma ( http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0 ). L'autre outil de couverture opensource est http://prdownloads.sourceforge.net/cobertura/cobertura-1.9-src.zip?download .

si vous parvenez finalement à faire ce que vous avez prévu, pls. partager avec la communauté ici avec votre tâche ant/bocaux.

Spring fournit un utilitaire de classe org.springframework.util.Chronomètre , selon JavaDoc:

simple chronomètre, permettant le chronométrage d'un certain nombre de tâches, exposant temps de fonctionnement total et temps de fonctionnement pour chaque tâche désignée.

Utilisation:

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

sortie:

StopWatch 'Performance Test Result': running time (millis) = 12829
-----------------------------------------
ms     %     Task name
-----------------------------------------
11907  036%  Method 1
00922  064%  Method 2

Avec Des Aspects:

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

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

j'ai modifié le code de la bonne réponse pour obtenir le résultat en quelques secondes:

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

Vous pouvez essayer de cette façon, si voulez savoir l'heure.

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

Ok, c'est une classe simple à utiliser pour le chronométrage simple de vos fonctions. Il est un exemple ci-dessous.

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

échantillon d'utilisation:

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

échantillon de sortie de la console:

Split time for [file to string]: 672 ms
Split time for [parse Json]: 893 ms
Final time for [get Schedule]: 1565 ms

en Java 8, une nouvelle classe appelée Instant est introduite. Selon le doc:

Instantanée représente le début d'une nanoseconde sur la ligne de temps. Ce la classe est utile pour générer un horodatage pour représenter le temps machine. La gamme de l'instant qui nécessite le stockage d'un nombre plus grand qu'un long. Pour ce faire, la classe stocke un long représentant epoch-secondes et un int représentant nanoseconde-de-seconde, qui sera toujours entre 0 et 999 999 999. L'époque secondes sont mesurés de L'époque Java standard de 1970-01-01T00: 00:00Z où instantes après l'époque ont des valeurs positives, et plus tôt instants ont les valeurs négatives. Pour les pièces epoch-second et nanoseconde, un plus la valeur est toujours plus tard sur la ligne qu'une plus petite valeur.

peut être utilisé comme:

Instant start = Instant.now();
try {
    Thread.sleep(7000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
Instant end = Instant.now();
System.out.println(Duration.between(start, end));

il imprime PT7.001S .

@Timed mesures de sortie exemple:

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

System.nanoTime() est un utilitaire de système assez précis pour mesurer le temps d'exécution. Mais attention, si vous utilisez le mode d'ordonnanceur préemptif (par défaut), cet utilitaire mesure en fait le temps d'horloge du mur et non le temps CPU. Par conséquent, vous pouvez remarquer des valeurs de temps d'exécution différentes d'un exécution à l'autre, en fonction des charges du système. Si vous cherchez du temps CPU, je pense que faire tourner votre programme en mode temps réel fera l'affaire. Vous devez utiliser RT linux. lien: programmation en temps Réel avec Linux

mesures de Performance sur ma machine

• du Système.nanoTime() : 750ns
Système
• .currentTimeMillis (): 18ns

, Comme mentionné, du Système.nanoTime() est censé mesurer le temps écoulé. Il suffit d'être conscient du coût si utilisé dans une boucle ou similaire.