दिलचस्प पोस्ट
जांच कर रहा है कि क्या मेरा विंडोज़ अनुप्रयोग चल रहा है कैसे php साइट के लिए ब्राउज़र कैश को रोकने के लिए मैं एक सामान्य विस्तार विधि के भीतर एक स्ट्रिंग स्तंभ नाम का उपयोग कर एक IQueryable पर ऑर्डरबी कैसे लागू कर सकता हूं? मामला-असंवेदनशील सूची छँटाई, परिणाम को कम करने के बिना? मैं विजुअल स्टूडियो 2013 से गिटहब के लिए एक मौजूदा समाधान कैसे जोड़ूं? डुप्लिकेट फ़ाइलों को ढूँढना और उन्हें निकालना मिसाम से इनोडीबी में सभी तालिकाओं को कैसे रूपांतरित करना है? संपत्ति फ़ोल्डर से 1M से अधिक फ़ाइलों को लोड करें क्या अधिक कुशल i ++ या ++ i है? C ++ में फ्लोट के लिए गोल () संदर्भ बनाम पॉइंटर्स का उपयोग कब करना क्यों सी # 3.0 ऑब्जेक्ट initializer कन्स्ट्रक्टर कोष्ठक वैकल्पिक हैं? क्रॉस डोमेन PHP सत्र Xcode के तहत आर्किटेक्चर x86_64 के लिए डुप्लिकेट प्रतीकों "1 9 3:% 1 एक वैध विन 32 आवेदन नहीं है" एक नया रेल एप्लीकेशन के साथ बग

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

मैं विधि का निष्पादन समय कैसे प्राप्त करूं? क्या समय के लिए चीज़ों के लिए एक टाइमर उपयोगिता वर्ग है, कितना समय लगता है काम करता है आदि?

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

वेब के समाधान से एकत्रित समाधान "मैं जावा में विधि का निष्पादन कैसे करता हूं?"

हमेशा पुराने तरीके से होता है:

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

मैं साधारण उत्तर के साथ जाना मेरे लिये कार्य करता है।

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

यह बहुत अच्छी तरह से काम करता है संकल्प स्पष्ट रूप से केवल मिलीसेकेंड के लिए है, आप सिस्टम। नैनोटाइम () के साथ बेहतर कर सकते हैं। दोनों (ऑपरेटिंग सिस्टम शेड्यूल स्लाइस, आदि) के लिए कुछ सीमाएँ हैं लेकिन यह बहुत अच्छी तरह से काम करता है

दो रनों में औसत (जितना अधिक बेहतर) और आपको एक अच्छा विचार मिलेगा

चलो दोस्तो! किसी ने ऐसा करने के लिए गवावा का उल्लेख नहीं किया (जो यकीनन भयानक है):

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

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

अच्छा भी:

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

नोट: Google Java के लिए जावा 1.6+ की आवश्यकता है

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

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

आउटपुट,

 PT5S 

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

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

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

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

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

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

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

तारीख

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

प्रणाली

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

अपाचे – स्टॉपवॉच

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

गूगल – स्टॉपवॉच

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

मानव पठनीय प्रारूप

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

जोडा-टाइम्स

 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 = Instant.now(); Thread.sleep(5000); Instant end = Instant.now(); System.out.println(Duration.between(start, end)); 

System.currentTimeMillis(); आपके एल्गोरिदम के प्रदर्शन को मापने के लिए एक अच्छा तरीका नहीं है। यह आपके कंप्यूटर स्क्रीन को देखते हुए उपयोगकर्ता के रूप में अनुभव के दौरान कुल समय को मापता है। इसमें पृष्ठभूमि में आपके कंप्यूटर पर चलने वाली हर चीज का समय भी शामिल होता है यह आपके वर्कस्टेशन पर चलने वाले बहुत सारे कार्यक्रमों के मामले में बहुत बड़ा फर्क पड़ेगा।

उचित दृष्टिकोण java.lang.management पैकेज का उपयोग कर रहा है।

http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking वेबसाइट से:

  • "उपयोगकर्ता का समय" आपके एप्लिकेशन का अपना कोड चलाने के लिए खर्च किया गया समय है।
  • "सिस्टम टाइम" आपके ऐप्लिकेशन की ओर से ओएस कोड चलाने में बिताए समय है (जैसे कि 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; } } 

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

नमूना कोड

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

जावा 8 के साथ आप हर सामान्य तरीकों से ऐसा कुछ भी कर सकते हैं:

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

समय के साथ यह पसंद है:

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

इस methode के साथ आप इसे तोड़ने के बिना अपने कोड में कहीं भी आसान समय माप कर सकते हैं। इस सरल उदाहरण में मैं सिर्फ समय प्रिंट करता हूं। क्या आप समय के लिए स्विच जोड़ सकते हैं, जैसे कि केवल डीबगमोड या कुछ समय में प्रिंट करें

यदि आप फ़ंक्शन के साथ काम कर रहे हैं तो आप ऐसा कुछ कर सकते हैं:

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

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

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

सिर्फ एक छोटा मोड़, यदि आप टूलींग का उपयोग नहीं करते हैं और कम निष्पादन समय के साथ समय के तरीकों का इस्तेमाल करना चाहते हैं: इसे कई बार निष्पादित करें, हर बार जब तक आप एक सेकंड तक नहीं पहुंचते हैं, या ऐसा करते हैं तब तक की संख्या को दोगुना करते हैं। इस प्रकार, सिस्टम को कॉल करने का समय। नैनो टाइम और आगे, न ही सिस्टम की सटीकता। नैनो टाइम परिणाम को बहुत प्रभावित करता है।

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

बेशक, दीवार घड़ी का उपयोग करने के बारे में चेतावनी लागू होती है: जेआईटी-संकलन, कई धागे / प्रक्रियाओं आदि के प्रभाव। इस प्रकार, आपको पहली बार इस विधि को कई बार निष्पादित करने की आवश्यकता है, जैसे जेआईटी कंपाइलर इसके काम करता है, और फिर इस परीक्षा को कई बार दोहराएं और सबसे कम निष्पादन समय लें।

वास्तव में अच्छा कोड

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

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

अधिक जानकारी डेवलपर मार्गदर्शिका में पाई जा सकती है

संपादित करें: परियोजना मृत लगता है

जेईपी 230: माइक्रोबैन्चमार्क स्वीट

एफवाईआई , जेईपी 230: माइक्रोबैंचमार्क सुइट एक ओपन जेडीके प्रस्ताव है:

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

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

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

इस बीच आप जावा माइक्रोबैन्चमार्क हार्नेस (जेएमएच) प्रोजेक्ट को देखना चाहते हैं जिस पर प्रस्ताव आधारित है।

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

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

ऐसा करने के कुछ तरीके हैं मैं आमतौर पर बस इस तरह से कुछ का उपयोग करने के लिए वापस आ जाते हैं:

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

या System.nanoTime () के साथ एक ही बात;

चीजों की बेंचमार्किंग पक्ष के बारे में कुछ और बातों के लिए यह एक भी हो सकता है: http://jetm.void.fm/ इसे कभी भी नहीं लगाया।

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

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

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

यदि आप दीवार घड़ी का समय चाहते हैं

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

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

आप एम्मा जैसे खुले स्रोत उपकरण टूल द्वारा उपयोग किए गए कोड को देख सकते हैं ( 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। इसे अपने चींटी कार्य / जार के साथ साझा करें।

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

मैंने सेकंड में परिणाम प्राप्त करने के लिए सही उत्तर से कोड संशोधित किया:

 long startTime = System.nanoTime(); methodCode ... long endTime = System.nanoTime(); double duration = (double)(endTime - startTime) / (Math.pow(10, 9)); Log.v(TAG, "MethodName time (s) = " + duration); 

वसंत एक उपयोगिता वर्ग 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; } 

आप इस तरह की कोशिश कर सकते हैं अगर सिर्फ समय जानना चाहते हो।

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

ठीक है, यह आपके कार्यों के साधारण सरल समय के लिए उपयोग करने के लिए एक साधारण वर्ग है इसके नीचे एक उदाहरण है

 public class Stopwatch { static long startTime; static long splitTime; static long endTime; public Stopwatch() { start(); } public void start() { startTime = System.currentTimeMillis(); splitTime = System.currentTimeMillis(); endTime = System.currentTimeMillis(); } public void split() { split(""); } public void split(String tag) { endTime = System.currentTimeMillis(); System.out.println("Split time for [" + tag + "]: " + (endTime - splitTime) + " ms"); splitTime = endTime; } public void end() { end(""); } public void end(String tag) { endTime = System.currentTimeMillis(); System.out.println("Final time for [" + tag + "]: " + (endTime - startTime) + " ms"); } } 

उपयोग का नमूना:

 public static Schedule getSchedule(Activity activity_context) { String scheduleJson = null; Schedule schedule = null; /*->*/ Stopwatch stopwatch = new Stopwatch(); InputStream scheduleJsonInputStream = activity_context.getResources().openRawResource(R.raw.skating_times); /*->*/ stopwatch.split("open raw resource"); scheduleJson = FileToString.convertStreamToString(scheduleJsonInputStream); /*->*/ stopwatch.split("file to string"); schedule = new Gson().fromJson(scheduleJson, Schedule.class); /*->*/ stopwatch.split("parse Json"); /*->*/ stopwatch.end("Method getSchedule"); return schedule; } 

कंसोल आउटपुट का नमूना:

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

System.nanoTime() निष्पादन समय को मापने के लिए एक बहुत सटीक प्रणाली उपयोगिता है। लेकिन सावधान रहें, यदि आप पूर्व-गतिशील शेड्यूलर मोड (डिफ़ॉल्ट) पर चल रहे हैं, तो यह सुविधा वास्तव में दीवार-घड़ी का समय निर्धारित करती है और CPU समय नहीं है इसलिए, आपको सिस्टम निष्पादन के आधार पर चलाने के लिए अलग-अलग निष्पादन समय मान दिखाई दे सकते हैं। यदि आप CPU समय की जांच करते हैं, तो मुझे लगता है कि वास्तविक समय मोड में आपके प्रोग्राम को चलाने से चाल होगी। आपको आरटी लिनक्स का उपयोग करना होगा लिंक: लिनक्स के साथ वास्तविक समय प्रोग्रामिंग

मेरे मशीन पर प्रदर्शन मापन

  • System.nanoTime (): 750ns
  • सिस्टम सीरेंटटाइम मिलिसे (): 18ns

जैसा कि उल्लेख किया गया है, सिस्टम। नैनो टाइम () को समय बीतने के उपाय माना जाता है। अगर लागत का इस्तेमाल किया जाता है तो लूप या समान तरह से इस्तेमाल किए जाने पर लागत के बारे में अवगत रहें

यह अच्छा होगा यदि जावा का बेहतर कार्यात्मक समर्थन था, ताकि कार्रवाई को मापने की जरूरत हो, उसे ब्लॉक में लपेटा जा सकता है:

 measure { // your operation here } 

जावा में यह अज्ञात कार्यों से किया जा सकता है, जो बहुत ही भावपूर्ण दिखते हैं

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

जावा 8 में Instant नामक एक नया क्लास पेश किया गया है। डॉक्टर के अनुसार:

तत्काल समय रेखा पर नैनोसेकंड की शुरुआत का प्रतिनिधित्व करता है। यह क्लास मशीन टाइम का प्रतिनिधित्व करने के लिए एक टाइम स्टैम्प तैयार करने के लिए उपयोगी है। एक पल की सीमा के लिए एक लंबे समय से बड़े संख्या के संग्रहण की आवश्यकता होती है। इसे हासिल करने के लिए, क्लास लंबे समय से प्रतिनिधित्व वाले युग-सेकंड का प्रतिनिधित्व करता है और एक इंट नैनोसेकंड-ऑफ-सेकंड का प्रतिनिधित्व करता है, जो कि हमेशा 0 और 99 9, 99 9, 999 के बीच होगा। युग-सेकंड को 1 971-01-01 -000: 00: 00 जेड के मानक जावा युग से मापा जाता है, जहां युग के बाद इंस्टेंसेस पॉजिटिव मान हैं, और पहले के इंस्टॉलेशन में ऋणात्मक मूल्य हैं। युग-सेकंड और नैनोसेकंड दोनों भागों के लिए, एक बड़ा मूल्य हमेशा बाद में एक छोटे मूल्य की तुलना में समय-रेखा पर होता है।

इसे इस रूप में प्रयोग किया जा सकता है:

 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 प्रिंट PT7.001S