Comment puis-je chronométrer l’exécution d’une méthode en Java?

Comment puis-je obtenir le temps d’exécution d’une méthode? Y a-t-il une classe d’utilitaire Timer pour des choses comme la durée de la tâche, etc.?

La plupart des recherches effectuées sur Google renvoient des résultats aux timers qui planifient les threads et les tâches, ce qui n’est pas ce que je veux.

    Il y a toujours la manière démodée:

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

    Je vais avec la réponse simple. Travaille pour moi.

     long startTime = System.currentTimeMillis(); doReallyLongThing(); long endTime = System.currentTimeMillis(); System.out.println("That took " + (endTime - startTime) + " milliseconds"); 

    Cela fonctionne assez bien. La résolution est évidemment seulement à la milliseconde, vous pouvez faire mieux avec System.nanoTime (). Il existe certaines limitations aux deux (tranches de planification du système d’exploitation, etc.), mais cela fonctionne plutôt bien.

    Moyenne sur quelques cycles (le mieux c’est) et vous aurez une bonne idée.

    Allez les gars! Personne n’a mentionné la méthode Guava (ce qui est sans doute génial):

     import com.google.common.base.Stopwatch; Stopwatch timer = Stopwatch.createStarted(); //method invocation LOG.info("Method took: " + timer.stop()); 

    La bonne chose est que Stopwatch.toSsortingng () fait un bon travail de sélection des unités de temps pour la mesure. Ie si la valeur est petite, ça va sortir 38 ns, si c’est long, ça montrera 5m 3s

    Encore mieux:

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

    Remarque: Google Guava nécessite Java 1.6+

    Utiliser Instant et Duration depuis la nouvelle API de Java 8,

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

    les sorties,

     PT5S 

    Utilisez un profileur (JProfiler, Netbeans Profiler, Visual VM, Eclipse Profiler, etc.). Vous obtiendrez les résultats les plus précis et serez le moins intrusif. Ils utilisent le mécanisme JVM intégré pour le profilage, qui peut également vous fournir des informations supplémentaires telles que des traces de stack, des chemins d’exécution et des résultats plus complets si nécessaire.

    Lorsque vous utilisez un profileur entièrement intégré, il est impossible de profiler une méthode. Clic droit, Profileur -> Ajouter aux méthodes racine. Ensuite, exécutez le profileur comme si vous faisiez un test ou un débogueur.

    Réuni tous les moyens possibles ensemble.

    Rendez-vous amoureux

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

    Format lisible par l’homme

     public static Ssortingng millisToShortDHMS(long duration) { Ssortingng 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 = Ssortingng.format("%02d:%02d:%02d.%04d", hours, minutes, seconds, millis); else res = Ssortingng.format("%dd %02d:%02d:%02d.%04d", days, hours, minutes, seconds, millis); return res; } 

    Guava: JAR Google Chronomètre «Un object de Stopwatch 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 « StopWatch fournit une API pratique pour les timings.

     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"); Ssortingng start = ms_SDF.format( new Date() ); // java.util.Date Thread.sleep(10000); Ssortingng 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 de date et heure Java à partir de Java 8 «Un object Duration représente une période de temps entre deux objects 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 fournit la classe utilitaire StopWatch 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 de l’AOP. Fouettez un intercepteur proxy autour de votre méthode et effectuez le chronométrage.

    Malheureusement, le quoi, le pourquoi et le comment d’AOP dépassent le cadre de cette réponse, mais c’est comme ça que je le ferais probablement.

    Edit: Voici un lien vers Spring AOP pour vous lancer, si vous le souhaitez. Il s’agit de l’implémentation la plus accessible d’AOP que Iive propose pour Java.

    De plus, étant donné les suggestions très simples de tous les autres, je devrais append que AOP est pour quand vous ne voulez pas que des choses comme le timing envahissent votre code. Mais dans de nombreux cas, cette approche simple et facile convient.

    System.currentTimeMillis(); N’EST PAS une bonne approche pour mesurer les performances de vos algorithmes. Il mesure le temps total que vous vivez en tant qu’utilisateur regardant l’écran de l’ordinateur. Il comprend également le temps consommé par tout ce qui tourne sur votre ordinateur en arrière-plan. Cela pourrait faire une énorme différence si vous avez beaucoup de programmes en cours d’exécution sur votre poste de travail.

    Une approche appropriée consiste à utiliser le package java.lang.management .

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

    • “Heure utilisateur” correspond au temps passé à exécuter le propre code de votre application.
    • “Heure système” correspond au temps passé à exécuter le code du système d’exploitation au nom de votre application (par exemple pour les E / S).

    getCpuTime() méthode getCpuTime() vous donne la sum 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 faire quelque chose comme ça avec toutes les méthodes normales:

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

    avec TimeIt aime:

     public class TimeIt { public static  T printTime(Callable 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 effectuer des mesures de temps faciles dans votre code sans le casser. Dans cet exemple simple, j’imprime simplement l’heure. Pouvez-vous append un commutateur pour TimeIt, par exemple pour imprimer uniquement l’heure dans DebugMode ou quelque chose.

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

     Function 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  Function printTime2(Function task) { return (t) -> { long startTime = System.currentTimeMillis(); R apply = task.apply(t); System.out.print((System.currentTimeMillis() - startTime) / 1000d + "s"); return apply; }; } 

    Nous pouvons également utiliser la classe StopWatch des communs Apache pour mesurer le temps.

    Code exemple

     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 des outils et que vous souhaitez chronométrer des méthodes avec un temps d’exécution réduit: exécutez-le plusieurs fois, en doublant chaque fois le nombre d’exécutions jusqu’à une seconde. Ainsi, l’heure de l’appel à System.nanoTime et ainsi de suite, ni la précision de System.nanoTime affectent beaucoup le résultat.

      int runs = 0, runsPerRound = 10; long begin = System.nanoTime(), end; do { for (int i=0; i end - begin); System.out.println("Time for timedMethod() is " + 0.000000001 * (end-begin) / runs + " seconds"); 

    Bien sûr, les mises en garde concernant l’utilisation de l’horloge murale s’appliquent: influences de la compilation JIT, de multiples threads / processus, etc. Ainsi, vous devez d’abord exécuter la méthode plusieurs fois, de sorte que le compilateur JIT fasse son travail, Répétez ce test plusieurs fois et prenez le temps d’exécution le plus bas.

    Nous utilisons les annotations AspectJ et Java à cette fin. Si nous avons besoin de connaître le temps d’exécution d’une méthode, nous pouvons simplement l’annoter. Une version plus avancée peut utiliser un propre niveau de journalisation pouvant être activé et désactivé au moment de 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; } [...] } 

    Vraiment un bon code.

    http://www.rgagnon.com/javadetails/java-0585.html

     import java.util.concurrent.TimeUnit; long startTime = System.currentTimeMillis(); ........ ........ ........ long finishTime = System.currentTimeMillis(); Ssortingng diff = millisToShortDHMS(finishTime - startTime); /** * converts time (in milliseconds) to human-readable format * "hh:mm:ss" */ public static Ssortingng millisToShortDHMS(long duration) { Ssortingng 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 = Ssortingng.format("%02d:%02d:%02d", hours, minutes, seconds); } else { res = Ssortingng.format("%dd%02d:%02d:%02d", days, hours, minutes, seconds); } return res; } 

    JEP 230: Suite Microbenchmark

    FYI, JEP 230: Microbenchmark Suite est une proposition d’ OpenJDK pour:

    Ajoutez une suite de base de micro-repères au code source JDK et aidez les développeurs à exécuter facilement les microbenchmarks existants et à en créer de nouveaux.

    Cette proposition n’a pas fait la coupure pour Java 9 mais peut être ajoutée plus tard.

    Java Microbenchmark Harness (JMH)

    En attendant, vous pouvez consulter le projet JMH (Java Microbenchmark Harness) sur lequel la proposition est basée.

     new Timer(""){{ // code to time }}.timeMe(); public class Timer { private final Ssortingng timerName; private long started; public Timer(Ssortingng timerName) { this.timerName = timerName; this.started = System.currentTimeMillis(); } public void timeMe() { System.out.println( Ssortingng.format("Execution of '%s' takes %dms.", timerName, started-System.currentTimeMillis())); } } 

    Vous pouvez utiliser Perf4j . Utilitaire très cool. L’utilisation est simple

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

    Vous trouverez plus d’informations dans le Guide du développeur.

    Edit: Le projet semble mort

    En utilisant les annotations AOP / AspectJ et @Loggable des aspects jcabi, vous pouvez le faire facilement et compact:

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

    Chaque appel à cette méthode sera envoyé à la fonction de consignation SLF4J avec le niveau de consignation DEBUG . Et chaque message de journal inclura le temps d’exécution.

    Je fais essentiellement des variations de ceci, mais compte tenu de la façon dont fonctionne la compilation hotspot, si vous voulez obtenir des résultats précis, vous devez jeter les premières mesures et vous assurer que vous utilisez la méthode dans une application réelle.

    Si le JIT décide de le comstackr, vos chiffres varieront considérablement. alors juste être conscient

    Il y a plusieurs façons de le faire. Je reviens normalement à utiliser simplement quelque chose comme ceci:

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

    ou la même chose avec System.nanoTime ();

    Pour ce qui est de l’parsing comparative, il semble y avoir aussi celui-ci: http://jetm.void.fm/

    Si vous voulez l’heure de l’horloge murale

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

    Comme l’a dit “skaffman”, utilisez AOP OU vous pouvez utiliser le tissage de code de temps d’exécution, tout comme les outils de couverture de méthode de test unitaire utilisés pour append de manière transparente les informations de synchronisation aux méthodes invoquées.

    Vous pouvez regarder le code utilisé par les outils d’outils open source 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 vous attendez, pls. partagez-la avec la communauté ici avec votre tâche / jar de fourmis.

    Spring fournit une classe d’utilitaires org.springframework.util.StopWatch , conformément à JavaDoc:

    Chronomètre simple, permettant de synchroniser un certain nombre de tâches, en exposant le temps total d’exécution et le temps d’exécution pour chaque tâche nommée.

    Usage:

     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 réponse correcte pour obtenir un résultat en 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 vous voulez simplement connaître l’heure.

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

    Ok, il s’agit d’une classe simple à utiliser pour un calendrier simple et simple de vos fonctions. Il y a un exemple en 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(Ssortingng tag) { endTime = System.currentTimeMillis(); System.out.println("Split time for [" + tag + "]: " + (endTime - splitTime) + " ms"); splitTime = endTime; } public void end() { end(""); } public void end(Ssortingng tag) { endTime = System.currentTimeMillis(); System.out.println("Final time for [" + tag + "]: " + (endTime - startTime) + " ms"); } } 

    Échantillon d’utilisation:

     public static Schedule getSchedule(Activity activity_context) { Ssortingng 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 = FileToSsortingng.convertStreamToSsortingng(scheduleJsonInputStream); /*->*/ stopwatch.split("file to ssortingng"); schedule = new Gson().fromJson(scheduleJson, Schedule.class); /*->*/ stopwatch.split("parse Json"); /*->*/ stopwatch.end("Method getSchedule"); return schedule; } 

    Exemple de sortie de console:

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

    Vous pouvez utiliser la bibliothèque Mesortingcs qui fournit divers instruments de mesure. Ajouter une dépendance:

       io.dropwizard.mesortingcs mesortingcs-core ${mesortingcs.version}   

    Et configurez-le pour votre environnement.

    Les méthodes peuvent être annotées avec @Timed :

     @Timed public void exampleMethod(){ // some code } 

    ou morceau de code enveloppé avec timer :

     final Timer timer = mesortingcsRegistry.timer("some_name"); final Timer.Context context = timer.time(); // timed code context.stop(); 

    Les mésortingques agrégées peuvent être exscopes vers la console, JMX, CSV ou autres.

    @Timed sortie de mésortingques @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 

    System.nanoTime() est un utilitaire système assez précis pour mesurer le temps d’exécution. Mais attention, si vous utilisez le mode pré-budgétisation préemptif (par défaut), cet utilitaire mesure en fait le temps de l’horloge et non le temps processeur. Par conséquent, vous pouvez remarquer des valeurs de temps d’exécution différentes entre l’exécution et l’exécution, en fonction des charges du système. Si vous recherchez le temps CPU, je pense que l’exécution de votre programme en mode temps réel fera l’affaire. Vous devez utiliser RT Linux. link: Programmation en temps réel avec Linux

    Mesures de performance sur ma machine

    • System.nanoTime (): 750ns
    • System.currentTimeMillis (): 18ns

    Comme mentionné, System.nanoTime () est pensé pour mesurer le temps écoulé. Juste être conscient du coût si utilisé insied une boucle ou similaire.

    Ce serait bien si java avait un meilleur support fonctionnel, de sorte que l’action qui doit être mesurée puisse être intégrée dans un bloc:

     measure { // your operation here } 

    En java, cela pourrait être fait par des fonctions anonymes, qui semblent trop verbeuses

     public interface Timer { void wrap(); } public class Logger { public static void logTime(Timer timer) { long start = System.currentTimeMillis(); timer.wrap(); System.out.println("" + (System.currentTimeMillis() - start) + "ms"); } public static void main(Ssortingng a[]) { Logger.logTime(new Timer() { public void wrap() { // Your method here timeConsumingOperation(); } }); } public static void timeConsumingOperation() { for (int i = 0; i<=10000; i++) { System.out.println("i=" +i); } } }