दिलचस्प पोस्ट
एंड्रॉइड के लिए स्पिनर पृष्ठभूमि डिजाइन और रंग कैसे बदल सकता है? त्रुटि को ठीक कैसे करें; 'त्रुटि: बूटस्ट्रैप टूलटिप्स को टिथर (http://github.hubspot.com/tether/) की आवश्यकता होती है' ऑटोबॉक्ज़िंग जावा में कुछ कॉल को अस्पष्ट क्यों करता है? मैं एक डाटा डाटाबेस को MySQL डाटाबेस में कैसे सम्मिलित कर सकता हूं? विधि चेनिंग – क्यों यह एक अच्छा अभ्यास है, या नहीं? मैं model.save पर सफलता कॉलबैक कैसे ट्रिगर करूँ? जब @क्व्यापाराम बनाम @ पाथपरम का उपयोग करें पूरे माइस् SQL डेटाबेस में ढूंढें और प्रतिस्थापित करें गंदा नाम से घोटाला नाम प्राप्त करना एक प्रभावी और आसान तरीके से पदानुक्रम, अभिभावक / बाल संबंध प्राप्त करना प्रदर्शन के बीच अंतर क्या है: इनलाइन और प्रदर्शन: इनलाइन-ब्लॉक? आर कंसोल के भीतर यूनिक्स "कम" कमांड के बराबर रूट लेआउट से संबंधित व्यू के निर्देशांक प्राप्त करना UICollectionViewCell में ऑटो लेआउट काम नहीं कर रहा है जब id में कोई डॉट शामिल होता है तो jquery के साथ आईडी द्वारा html नोड्स को कैसे चुनना है?

System.currentTimeMillis बनाम System.nanoTime

सटीकता बनाम। शुद्धता

मैं क्या जानना चाहूंगा कि क्या मुझे अपने गेम में मेरे ऑब्जेक्ट के पदों को अपडेट करते समय सिस्टम सीरेंटटाइम मिलििस () या सिस्टम। नैनो टाइम () का उपयोग करना चाहिए? आंदोलन में उनका परिवर्तन अंतिम कॉल के बाद से समाप्त हुए समय के लिए सीधे आनुपातिक होता है और मैं यथासंभव सटीक होना चाहता हूं।

मैंने पढ़ा है कि विभिन्न ऑपरेटिंग सिस्टम के बीच कुछ गंभीर समय-समाधान समस्याएं हैं (अर्थात् मैक / लिनक्स में लगभग 1 एमएस का संकल्प है जबकि विंडोज़ का 50 एमएमएस रिज़ॉल्यूशन है?) मैं पहले से ही विंडोज़ पर अपने क्षुधा चला रहा हूँ और 50 एमएमएस संकल्प बहुत गलत लगता है।

क्या दो मैं सूचीबद्ध की तुलना में बेहतर विकल्प हैं?

कोई सुझाव / टिप्पणी?

वेब के समाधान से एकत्रित समाधान "System.currentTimeMillis बनाम System.nanoTime"

यदि आप केवल बीत चुके समय के बेहद सटीक माप की तलाश कर रहे हैं, तो System.nanoTime() उपयोग करें। System.currentTimeMillis() आपको युग के बाद से मिलीसेकंड में सबसे सटीक संभव समय दे देगा, लेकिन System.nanoTime() टाइम System.nanoTime() आपको कुछ मनमाना बिंदु के सापेक्ष, नैनोसेकंड-सटीक समय देता है।

जावा प्रलेखन से:

 public static long nanoTime() 

नैनोसेकंड में, सबसे सटीक उपलब्ध सिस्टम टाइमर के वर्तमान मूल्य को वापस लौटाता है।

इस पद्धति का उपयोग केवल बीते समय को मापने के लिए किया जा सकता है और यह सिस्टम या दीवार-घड़ी के किसी भी समय की अवधारणा से संबंधित नहीं है। लौटाई मूल्य कुछ निश्चित लेकिन मनमाना समय (शायद भविष्य में, इसलिए मूल्य नकारात्मक हो सकता है) के कारण नैनोसेकंड प्रस्तुत करता है। यह विधि नैनोसेकंड परिशुद्धता प्रदान करती है, लेकिन नैनोसेकंड सटीकता जरूरी नहीं है। कोई गारंटी नहीं है कि अक्सर मूल्य कैसे बदलते हैं संख्यात्मक अतिप्रवाह के कारण लगभग 292 वर्षों (2 63 नैनोसेकेंड) से अधिक समय तक आने वाले कॉल्स में अंतर सटीक रूप से बीता हुआ समय की गणना नहीं करेगा।

उदाहरण के लिए, यह मापने के लिए कि कुछ कोड निष्पादित करने के लिए कब तक ले जाता है:

 long startTime = System.nanoTime(); // ... the code being measured ... long estimatedTime = System.nanoTime() - startTime; 

यह भी देखें: JavaDoc System.nanoTime () और JavaDoc System.currentTimeMillis () अधिक जानकारी के लिए

थ्रेड-सुरक्षा

चूंकि इसके अलावा किसी और ने इसका उल्लेख नहीं किया है …

असुरक्षित

विभिन्न थ्रेड्स के बीच System.nanoTime()System.nanoTime() कॉल्स के परिणामों की तुलना करना सुरक्षित नहीं है System.nanoTime() यहां तक ​​कि यदि धागे की घटनाओं को अनुमान लगाने योग्य क्रम में हो, तो नैनोसेकेंड में अंतर सकारात्मक या नकारात्मक हो सकता है

सुरक्षित

System.currentTimeMillis() धागे के बीच उपयोग के लिए सुरक्षित है

Arkadiy द्वारा अद्यतन: मैंने ओरेकल जावा 8 में विंडोज 7 पर System.currentTimeMillis() का अधिक सही व्यवहार देखा है। समय 1 मिलीसेकंड सटीक के साथ वापस किया गया था ओपनजेडीके में सोर्स कोड बदल नहीं गया है, इसलिए मैं नहीं जानता कि बेहतर व्यवहार क्यों होता है


डेविड होम्स ऑफ सन ने एक ब्लॉग आलेख पोस्ट किया जो दो साल पहले जावा टाइमिंग एपीआई (विशेष रूप से System.currentTimeMillis() और System.nanoTime() ) पर बहुत विस्तृत रूप से दिखता है, जब आप इसका उपयोग करना चाहते हैं, और वे कैसे काम आंतरिक रूप से

हॉटस्पॉट वीएम के अंदर: घड़ियां, टाइमर और शेड्यूलिंग इवेंट्स – भाग I – विंडोज़

एपीआई के लिए विंडोज पर जावा द्वारा उपयोग किए जाने वाले टाइमर का एक बहुत दिलचस्प पहलू, जो समयबद्ध प्रतीक्षा पैरामीटर है, यह है कि टाइमर का रिज़ॉल्यूशन अन्य एपीआई कॉलों के आधार पर बदल सकता है – सिस्टम चौड़ा (न केवल विशिष्ट प्रक्रिया में) । वह एक उदाहरण दिखाता है, जहां Thread.sleep() का उपयोग करने से इस संकल्प को बदलना होगा।

पुराने जेवीएम में System.nanoTime() समर्थित नहीं है। यदि यह एक चिंता का विषय है, तो currentTimeMillis साथ currentTimeMillis

सटीकता के बारे में, आप लगभग सही हैं कुछ विंडोज मशीनों पर, currentTimeMillis() के बारे में 10ms (नहीं 50ms) का एक संकल्प है। मुझे यकीन नहीं है कि क्यों, लेकिन कुछ विंडोज़ मशीन लिनक्स मशीनों के समान सटीक हैं

मैंने अतीत में ग्रेगिटिमर को मध्यम सफलता के साथ प्रयोग किया है।

जैसा कि दूसरों ने कहा है, वर्तमान टाइममिलिस घड़ी का समय है, जो डेलाइट सेविंग टाइम के कारण बदल जाता है, उपयोगकर्ताओं को समय सेटिंग्स बदलते हैं, छलांग सेकंड, और इंटरनेट समय सिंक यदि आपका ऐप बीता हुआ समय मानों को एक-एक करके बढ़ाता है, तो आप नैनो टाइम को बजाय पसंद कर सकते हैं।

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

यदि आप घड़ी का समय का उपयोग करना चाहते हैं, लेकिन इंटरनेट समय के समन्वयन के कारण असंतोष से बचने के लिए, आप मेनेटबर्ग जैसे एनटीपी क्लाइंट पर विचार कर सकते हैं, जो घड़ी की समय-समय पर रीसेट करने के बजाय घड़ी दर की "धुनों"

मेरा अपना व्यक्तिगत अनुभव ही बयां होता है। एक मौसम के अनुप्रयोग में जो मैंने विकसित किया था, मैं यादृच्छिक रूप से होने वाली हवा की गति स्पाइक्स मिल रहा था मेरे लिए यह समझने में थोड़ी देर लग गई कि एक विशिष्ट पीसी पर घड़ी के समय के व्यवहार से मेरा टाइमबेस खराब हो रहा था। जब मैं नैनो टाइम का इस्तेमाल करना शुरू कर रहा था तो मेरी सारी समस्याएं गायब हो गईं। सुसंगतता (नीरसता) कच्चे सटीक या पूर्ण सटीकता की तुलना में मेरे आवेदन के लिए अधिक महत्वपूर्ण था।

हां, यदि इस तरह की सटीक आवश्यकता है System.nanoTime() उपयोग करें, लेकिन पता है कि आपको जावा 5+ जेवीएम की आवश्यकता है।

मेरे एक्सपी सिस्टम पर, मैं देखता हूं कि सिस्टम समय कम से कम 100 माइक्रोसॉन्ड्स के लिए 278 नैनोसेकेंड को निम्न कोड का उपयोग कर रहा है:

 private void test() { System.out.println("currentTimeMillis: "+System.currentTimeMillis()); System.out.println("nanoTime : "+System.nanoTime()); System.out.println(); testNano(false); // to sync with currentTimeMillis() timer tick for(int xa=0; xa<10; xa++) { testNano(true); } } private void testNano(boolean shw) { long strMS=System.currentTimeMillis(); long strNS=System.nanoTime(); long curMS; while((curMS=System.currentTimeMillis()) == strMS) { if(shw) { System.out.println("Nano: "+(System.nanoTime()-strNS)); } } if(shw) { System.out.println("Nano: "+(System.nanoTime()-strNS)+", Milli: "+(curMS-strMS)); } } 

मैंने नैनोटिमे के साथ अच्छा अनुभव किया है यह जेएनआई लाइब्रेरी का उपयोग करते हुए, दीवार की घड़ी को दो लम्बे (सेकंड के बाद से युग और नैनोसेकंड से सेकंड) के रूप में प्रदान करता है। यह विंडोज़ और लिनक्स दोनों के लिए precompiled जेएनआई भाग के साथ उपलब्ध है।

गेम ग्राफिक्स और चिकनी स्थिति अपडेट के लिए, System.nanoTime() बजाय System.nanoTime() उपयोग करें। मैंने वर्तमान टाइममेलिस () से एक खेल में नैनोइट () को स्विच किया और गति की चिकनाई में एक प्रमुख दृश्य सुधार मिला।

हालांकि एक मिलीसेकेंड लग सकता है कि यह पहले से ही सटीक होना चाहिए, लेकिन यह नहीं है। कारक nanoTime() सुधार हो सकता है इसमें शामिल हैं:

  • दीवार-घड़ी संकल्प के नीचे सटीक पिक्सेल स्थिति
  • पिक्सल के बीच एंटी-एरिया की क्षमता, यदि आप चाहते हैं
  • विंडोज दीवार-घड़ी अशुद्धि
  • घड़ी घबराना (जब दीवार-घड़ी वास्तव में आगे बढ़ जाती है की विसंगति)

अन्य उत्तरों के मुताबिक, नैनो टाइम में एक प्रदर्शन लागत होती है, जिसे बार-बार कहा जाता है – यह फ्रेम प्रति एक बार कॉल करने के लिए सबसे अच्छा होगा, और पूरे फ्रेम की गणना करने के लिए समान मूल्य का उपयोग करेगा

System.currentTimeMillis() बीता हुआ समय के लिए सुरक्षित नहीं है क्योंकि यह पद्धति प्रणाली के वास्तविक समय घड़ी के परिवर्तनों के प्रति संवेदनशील है। आपको System.nanoTime उपयोग करना चाहिए कृपया जावा सिस्टम सहायता देखें:

नैनो टाइम विधि के बारे में:

.. यह पद्धति नैनोसेकंड परिशुद्धता प्रदान करती है, लेकिन जरूरी नहीं कि नैनोसेकंड रिजॉल्यूशन (जो कि, कितनी बार मूल्य में परिवर्तन होता है) – कोई गारंटी नहीं दी जाती है, इसके अलावा कम से कम वर्तमान टाइममेलीस () की तरह ही कोई भी गारंटी नहीं है।

यदि आप System.currentTimeMillis() उपयोग करते हैं तो आपका बीत गया समय नकारात्मक हो सकता है (वापस <- भविष्य में)

System.currentTimeMillis() बीता हुआ समय के लिए सुरक्षित नहीं है क्योंकि यह विधि सिस्टम के sy समय के प्रति संवेदनशील है। आपको System.nanoTime उपयोग करना चाहिए कृपया जावा सिस्टम सहायता देखें:

नैनो टाइम विधि के बारे में:

.. यह पद्धति नैनोसेकंड परिशुद्धता प्रदान करती है, लेकिन जरूरी नहीं कि नैनोसेकंड रिजॉल्यूशन (जो कि, कितनी बार मूल्य में परिवर्तन होता है) – कोई गारंटी नहीं दी जाती है, इसके अलावा कम से कम वर्तमान टाइममेलीस () की तरह ही कोई भी गारंटी नहीं है।

यदि आप System.currentTimeMillis() उपयोग करते हैं तो आपका बीत गया समय नकारात्मक हो सकता है (वापस <- भविष्य में)

यहाँ एक बात नैनो टाइम विधि की असंगतता है। यह उसी इनपुट के लिए बहुत सुसंगत मान नहीं देती है। कंटेनेंटटाइम प्रदर्शन और स्थिरता के मामले में बेहतर है, और यह भी, हालांकि नैनो टाइम के रूप में सटीक नहीं है, त्रुटि का एक कम अंतर है , और इसलिए इसके मूल्य में अधिक सटीकता। इसलिए मैं सुझाव देता हूं कि आप currentTimeMillis का उपयोग करें