मैं जावा में किसी विधि के निष्पादन को कैसे करूं?


834
  1. मुझे विधि के निष्पादन का समय कैसे मिलता है?
  2. क्या Timerटाइमिंग जैसे कामों के लिए एक यूटिलिटी क्लास है जिसमें कोई कार्य कितना समय लगता है, आदि?

Google पर अधिकांश खोजें थ्रेड्स और कार्यों को शेड्यूल करने वाले टाइमर के लिए परिणाम देती हैं, जो कि मैं नहीं चाहता हूं।


JAMON एपीआई एक नि: शुल्क, सरल, उच्च प्रदर्शन, थ्रेड सेफ, जावा एपीआई है जो डेवलपर्स को उत्पादन अनुप्रयोगों के प्रदर्शन और मापनीयता की आसानी से निगरानी करने की अनुमति देता है। JAMON ट्रैक हिट, निष्पादन समय (कुल, औसत, न्यूनतम, अधिकतम, std देव) और अधिक ट्रैक करता है। http://jamonapi.sourceforge.net/ डाउनलोड: http://sourceforge.net/project/showfiles.php?group_id=96550
माइक

1
आप अपाचे कॉमन्स लैंग स्टॉपवॉच क्लास को भी देखना चाहेंगे । एक सरल लेकिन उपयोगी उपयोगिता वर्ग।


हां, स्टॉपवॉच इसके लिए बहुत अच्छा है।
शुभम पांडेय

जावा 8 Instantकक्षा का उपयोग करते हुए : 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 तक नहीं जोड़ा गया था
जॉन गार्डनर

11
यह (या System.currentTimeMillis ()) का उपयोग करके लगता है कि यह आमतौर पर जावा में किया गया है ... जो मैंने वैसे भी देखा है। यह अभी भी मुझे बहुत ही आश्चर्यचकित करता है कि इसमें कोई स्पिफली बिल्ट-इन क्लास नहीं है, जैसे कि टाइमर t = new Timer (); स्ट्रिंग s = t.getElapsed (प्रारूप); आदि ...
ओगरे Psalm33

18
नैनोटाइम वर्तमान समय की तुलना में सटीकता की गारंटी नहीं देता है (), हालांकि यह आमतौर पर होता है। फ़ोरम। sun.com/thread.jspa?messageID=9460663 और simongbrown.com/blog/2007/08/20/…
जेम्स

10
बेशक, माइक्रो-बेंचमार्किंग के नुकसान को याद रखना हमेशा महत्वपूर्ण होता है, जैसे कि कंपाइलर / जेवीएम ऑप्टिमाइज़ेशन जो परिणाम को विकृत कर सकते हैं = 8-)
युवल

18
अंत में ब्लॉक के लिए कोई आवश्यकता नहीं है क्योंकि अपवाद को फेंक दिए जाने पर एंडटाइम का उपयोग नहीं किया जाएगा।
पीटर लॉरी

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 ();
स्टीव जी

ठीक है, मैं इसे आधिकारिक उत्तर के रूप में स्वीकार करने वाला था जब तक मैं स्टीव जी की टिप्पणी नहीं पढ़ता। महान टिडबिट, स्टीव!
ओगरे Psalm33

4
नैनोटाइम () वर्तमान समय की तुलना में सटीकता की गारंटी नहीं देता है, लेकिन कई जेवीएम कार्यान्वयन नैनो टाइम के साथ बेहतर सटीकता रखते हैं।
जेम्स स्कैच

5
@JamesSchek आपको वास्तव में अपने शब्दों को देखने की आवश्यकता है, जैसा कि मैंने पहले ही इस समान टिप्पणी का उल्लेख कहीं और किया है; nanoTimeहोने की गारंटी है दृढ़ रूप में कम से कम के रूप में currentTimeMillisdocs.oracle.com/javase/7/docs/api/java/lang/…
b1nary.atr0phy

इसका एक मामूली फायदा currentTimeMillisयह है कि यह एक वास्तविक टाइमस्टैम्प है, और इसका उपयोग प्रारंभ / समाप्ति समय के साथ-साथ लॉग करने के लिए भी किया जा सकता है, जबकि nanoTime"का उपयोग केवल बीते हुए समय को मापने के लिए किया जा सकता है और सिस्टम या दीवार-घड़ी समय की किसी भी अन्य धारणा से संबंधित नहीं है। । "
ब्रैड पार्क

177

चलो दोस्तो! किसी ने भी अमरूद का जिक्र ऐसा नहीं किया (जो यकीनन कमाल का है):

import com.google.common.base.Stopwatch;

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

अच्छी बात यह है कि स्टॉपवॉच.टोस्ट्रिंग () माप के लिए समय इकाइयों का चयन करने का एक अच्छा काम करता है। यानी अगर मूल्य छोटा है, तो यह 38 ns आउटपुट करेगा, अगर यह लंबा है, तो यह 5m 3s दिखाएगा

यहां तक ​​कि अच्छे:

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

नोट: Google अमरूद को जावा 1.6+ की आवश्यकता है


21
दुर्भाग्य से, अमरूद की स्टॉपवॉच थ्रेड-सुरक्षित नहीं है। मैंने इसे बहुत कठिनाई से सीखा है।
डेक्सटर लेगास्पी

6
@DexterLegaspi आपके अनुभव में बहुत दिलचस्पी होगी! साझा करने के लिए परवाह?
सिद्धार्थ

1
समानांतर में स्टॉपवॉच का उपयोग करने से आपको start()कई बार एक पंक्ति में (उसी के लिए stop()) कॉल करना होगा ।
मिंगवी सैमुअल

141

जावा 8 के नए एपीआई से त्वरित और अवधि का उपयोग करना ,

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

आउटपुट,

PT5S

2
धन्यवाद, मैं सामने पीटी होने के बिना परिणाम कैसे कर सकता हूं?
java123999

1
विधि के साथ समस्या यह है कि इंस्टेंट में मिलि और नैनो दूसरी परिशुद्धता की समस्या नहीं है। Ref: stackoverflow.com/questions/20689055/…
prashantsunkari

8
@ java123999: आप कॉल कर सकते हैं Duration.between(start, end).getSeconds()Durationअन्य समय इकाइयों में परिवर्तित करने की विधियाँ भी हैं, जैसे toMillis()कि मिलीसेकंड में परिवर्तित।
एमिल लुंडे

100

एक साथ एक ही स्थान पर सभी संभव तरीकों को इकट्ठा किया।

तारीख

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 स्टॉपवॉच जार «स्टॉपवॉच का एक उद्देश्य नैनोसेकंड में बीता समय को मापना है।

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

अपाचे कॉमन्स लैंग जार « स्टॉपवॉच समय के लिए एक सुविधाजनक एपीआई प्रदान करता है।

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 टाइम

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

जावा दिनांक समय जावा 8 से एपीआई «एक अवधि वस्तु दो त्वरित वस्तुओं के बीच की अवधि का प्रतिनिधित्व करती है ।

Instant start = java.time.Instant.now();
    Thread.sleep(1000);
Instant end = java.time.Instant.now();
Duration between = java.time.Duration.between(start, end);
System.out.println( between ); // PT1.001S
System.out.format("%dD, %02d:%02d:%02d.%04d \n", between.toDays(),
        between.toHours(), between.toMinutes(), between.getSeconds(), between.toMillis()); // 0D, 00:00:01.1001 

स्प्रिंग फ्रेमवर्क जावा में बीता समय को मापने के लिए स्टॉपवॉच उपयोगिता वर्गप्रदान करता है।

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]

अमरूद, अपाचे कॉमन्स और स्प्रिंग फ्रेमवर्क की स्टॉपवॉच थ्रेड सुरक्षित नहीं हैं। उत्पादन उपयोग के लिए सुरक्षित नहीं है।
दीपक पुत्रय

@DeepakPuthraya फिर कौन सी लाइब्रेरी का उपयोग करना है जो उत्पादन उपयोग के लिए सुरक्षित है?
गौरव

1
@DeepakPuthraya आप जावा 8 का उपयोग कर सकते हैं बशर्ते जावा तिथि समय एपीआई। जो सरल है।
यश

IMO इस पोस्ट से फायदा होगा अगर हर समाधान सिस्टम के आउटपुट को भी दिखाएगा।
BAERUS

87

प्रोफाइलर (JProfiler, Netbeans Profiler, Visual VM, Eclipse Profiler, आदि) का उपयोग करें। आप सबसे सटीक परिणाम प्राप्त करेंगे और कम से कम घुसपैठ है। वे प्रोफाइलिंग के लिए बिल्ट-इन JVM मैकेनिज्म का उपयोग करते हैं जो आपको स्टैक ट्रेस, एक्जीक्यूशन पाथ और यदि आवश्यक हो तो अधिक व्यापक परिणाम जैसी अतिरिक्त जानकारी भी दे सकता है।

पूरी तरह से एकीकृत प्रोफाइलर का उपयोग करते समय, यह एक विधि को प्रोफाइल करने के लिए फ़ेलिव तुच्छ है। राइट क्लिक करें, Profiler -> रूट विधियों में जोड़ें। फिर प्रोफाइलर को वैसे ही चलाएं जैसे आप टेस्ट रन या डीबगर कर रहे थे।


यह भी एक शानदार सुझाव था, और जब मैंने इस जवाब को पढ़ा, तो मेरे लिए उन "डुह" लाइट-बल्ब क्षणों में से एक था। हमारी परियोजना JDeveloper का उपयोग करती है, लेकिन मैंने जाँच की, और निश्चित रूप से पर्याप्त है, यह एक अंतर्निर्मित प्रोफाइलर है!
ओगरे Psalm33

2
जावा 7 से 40 का निर्माण (मुझे लगता है) वे पूर्व JRockits उड़ान रिकॉर्डर जावा (जावा मिशन नियंत्रण के लिए खोज)
नील्स Bech नीलसन

ज़रूर पढ़ें @NielsBechNielsen! oracle.com/technetwork/java/javaseproducts/mission-control/…
Ogre Psalm33

उदाहरण के लिए, विज़ुअल वीएम द्वारा जावा में विधि का निष्पादन कैसे प्राप्त करें?
okwap

41

यह शायद वह नहीं है जो आप मुझे कहना चाहते थे, लेकिन यह एओपी का एक अच्छा उपयोग है। अपने तरीके के आसपास एक प्रॉक्सी इंटरसेप्टर को व्हिप करें, और वहां टाइमिंग करें।

एओपी का क्या, क्यों और कैसे, बल्कि इस उत्तर के दायरे से परे है, दुख की बात है, लेकिन यह है कि मैं इसे कैसे करूँगा।

संपादित करें: यदि आप उत्सुक हैं, तो आपको शुरू करने के लिए स्प्रिंग एओपी की एक कड़ी है। यह AOP का सबसे सुलभ कार्यान्वयन है जो Iava जावा के लिए आता है।

इसके अलावा, हर किसी के बहुत ही सरल सुझावों को देखते हुए, मुझे यह जोड़ना चाहिए कि एओपी तब है जब आप अपने कोड पर आक्रमण करने के लिए समय जैसी चीजें नहीं चाहते हैं। लेकिन कई मामलों में, उस तरह का सरल और आसान तरीका ठीक है।


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 वेबसाइट:

  • "उपयोगकर्ता का समय" आपके आवेदन के अपने कोड को चलाने का समय है।
  • "सिस्टम का समय" आपके एप्लिकेशन (जैसे कि I / O) के लिए OS कोड चलाने में लगने वाला समय है।

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
यह निश्चित रूप से एक अच्छा बिंदु है, कि "उपयोगकर्ता का समय" (दीवार-घड़ी का समय) हमेशा प्रदर्शन का एक बड़ा उपाय नहीं है, खासकर एक बहु-थ्रेडेड प्रोग्राम में।
ओगरे Psalm33

यह वह उत्तर है जिसकी मुझे तलाश है।
झाओगंग

30

जावा 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 या कुछ और में समय मुद्रित करें।

आप के साथ काम कर रहे हैं समारोह आप इस तरह somthing कर सकते हैं:

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

यह अन्य समाधानों की तुलना में बहुत बेहतर दिखता है। स्प्रिंग एओपी के करीब इसकी तुलना में अभी तक हल्का है। सच जावा 8 रास्ता! +1 धन्यवाद!
अमित कुमार

हो सकता है कि यह आपको अच्छा लगे, क्योंकि स्टीफन फैंसी नए जावा फंक्शन्स का उपयोग कर रहा है। लेकिन मुझे लगता है कि यह पढ़ने और समझने में मुश्किल है।
स्टिमपसन कैट

18

इसके अलावा, हम समय को मापने के लिए अपाचे कॉमन्स के स्टॉपवॉच वर्ग का उपयोग कर सकते हैं।

नमूना कोड

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

बस एक छोटा सा मोड़, यदि आप टूलींग का उपयोग नहीं करते हैं और कम निष्पादन समय के साथ समय के तरीकों को चाहते हैं: इसे कई बार निष्पादित करें, हर बार जब तक आप एक दूसरे तक नहीं पहुंचते हैं, तब तक इसे निष्पादित किया जाता है। इस प्रकार, Call to 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: माइक्रोबेनमार्क सूट

FYI करें, JEP 230: माइक्रोबेनमार्क सूट एक OpenJDK परियोजना है:

JDK स्रोत कोड में माइक्रोबेनचर्च का एक मूल सूट जोड़ें, और डेवलपर्स के लिए मौजूदा माइक्रोबैनचर्च चलाना और नए बनाना आसान बनाते हैं।

यह फीचर जावा 12 में आया ।

जावा माइक्रोबेनमार्क हार्नेस (JMH)

जावा के पुराने संस्करणों के लिए, जावा माइक्रोबेनमार्क हार्नेस (JMH) परियोजना पर एक नज़र डालें, जिस पर JEP 230 आधारित है।


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
वास्तव में सवाल यह था कि एक विधि को कितना समय लगता है, इसकी गणना कैसे की जाए, इसे कैसे प्रारूपित किया जाए। हालाँकि यह सवाल काफी पुराना है (लगभग चार साल!)। पुराने थ्रेड्स को पुनर्जीवित करने से बचने की कोशिश करें जब तक कि प्रतिक्रिया मौजूदा प्रतिक्रियाओं पर कुछ नया और महत्वपूर्ण जोड़ न दे।
लेह

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); }
रिक बार्खहाउस

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 भी अच्छे आँकड़े उत्पन्न कर सकता है ।
पास्के

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
अपनी खुद की साधारण क्लास को रोल करना एक अच्छा विकल्प है जब आपके पास पहले से ही बिल्ड सिस्टम और आश्रित ओटीएस सेट है, और एक अन्य ओटीएस पैकेज में खींचना नहीं चाहते हैं जिसमें एक उपयोगिता टाइमर क्लास शामिल है।
ओगरे Psalm33

7

मैं मूल रूप से इस की विविधताएं करता हूं, लेकिन यह देखते हुए कि हॉटस्पॉट संकलन कैसे काम करता है, यदि आप सटीक परिणाम प्राप्त करना चाहते हैं तो आपको पहले कुछ माप फेंकने की जरूरत है और सुनिश्चित करें कि आप एक वास्तविक दुनिया में विधि का उपयोग कर रहे हैं (एप्लिकेशन विशिष्ट पढ़ें)।

यदि JIT इसे संकलित करने का निर्णय लेती है तो आपकी संख्या में भारी अंतर होगा। तो बस जागरूक रहें


7

AOP / AspectJ और जेकबी-पहलुओं@Loggable से एनोटेशन का उपयोग करके आप इसे आसान और कॉम्पैक्ट कर सकते हैं:

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

इस पद्धति की प्रत्येक कॉल DEBUGलॉगिंग स्तर के साथ SLF4J लॉगिंग सुविधा में भेजी जाएगी । और हर लॉग संदेश में निष्पादन समय शामिल होगा।


7

स्प्रिंग 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 के साथ इसका उपयोग करना संभव है?
18

7

मैंने विधि निष्पादन समय को बहुत पठनीय रूप में मुद्रित करने के लिए एक विधि लिखी है। उदाहरण के लिए, 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");
    }
}

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
public void exampleMethod(){
    // some code
}

या टाइमर के साथ लिपटा कोड का टुकड़ा :

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

एकत्रित मेट्रिक्स कंसोल, जेएमएक्स, सीएसवी या अन्य को निर्यात कर सकते हैं।

@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

जैसा कि "स्केफमैन" ने कहा, एओपी का उपयोग करें या आप रन टाइम बाईटेककोड बुनाई का उपयोग कर सकते हैं, ठीक उसी तरह जैसे यूनिट टेस्ट मेथड कवरेज टूल्स का उपयोग किया जाता है ताकि समय-समय पर जानकारी को आमंत्रित किए गए तरीकों से जोड़ा जा सके।

आप खुले स्रोत उपकरण टूल्स जैसे कि एम्मा ( http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_moror=0 ) पर उपयोग किए गए कोड को देख सकते हैं । अन्य ओपनसोर्स कवरेज टूल http://prdownloads.sourceforge.net/cobertura/cobertura-1.9-src.zip?download है

यदि आप अंततः वही करने का प्रबंधन करते हैं जो आप के लिए निर्धारित करते हैं, तो pls। इसे अपने चींटी कार्य / जार के साथ समुदाय के साथ वापस साझा करें।



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

आप स्प्रिंग कोर प्रोजेक्ट से स्टॉपवॉच क्लास का उपयोग कर सकते हैं:

कोड:

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है। डॉक्टर के अनुसार:

इंस्टेंट समय रेखा पर एक नैनोसेकंड की शुरुआत का प्रतिनिधित्व करता है। यह वर्ग मशीन समय का प्रतिनिधित्व करने के लिए एक समय टिकट बनाने के लिए उपयोगी है। एक पल की सीमा के लिए एक लंबे समय से बड़ी संख्या के भंडारण की आवश्यकता होती है। इसे प्राप्त करने के लिए, क्लास एक लंबे प्रतिनिधित्व वाले युगों-सेकंडों को संग्रहीत करता है और एक नैनो-सेकेंड-ऑफ-सेकंड का प्रतिनिधित्व करता है, जो हमेशा 0 और 999,999,999 के बीच रहेगा। युग-सेकंड को 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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.